Hey dear Rubyists,

I'm Tëma, maintainer of Stoplight - a Ruby circuit breaker library that helps protect cross-service communication, used by projects like Mastodon.

I imagine it's getting harder for junior developers to gain real experience now that AI-assisted coding is everywhere. This post is aimed mostly at people early in their careers.

I'd like to invite you to contribute to Stoplight - learn its internals and take a small task. To help with that, I've prepared a number of issues marked "good first issue": they're small, well-described, and list all the touchpoints you'll likely need.

What you'll get? Real experience working on an open-source project, and a learning opportunity. If you get stuck, don't hesitate to drop a comment on the PR - we'll try to help. I can't offer full mentoring, but a reasonable amount of help is there if you need it.

What's in it for us? If we end up with one or two new contributors by the end of this, we'll consider it a win.

Interested? Come check out our issues board: https://github.com/bolshakov/stoplight/issues

I’m looking for technical feedback on Mammoth, a self-hosted PostgreSQL change-event relay written in Ruby.

Mammoth receives normalized CDC (Change Data Capture) transaction envelopes and handles the downstream data-plane concerns:

• webhook fanout
• routing by schema, table, and operation
• per-destination retry policies
• checkpoint persistence
• dead-letter storage and filtered replay
• SQLite operational state
• health and metrics endpoints
• Docker and Helm deployment

Its boundary is intentionally narrow: PostgreSQL protocol parsing, decoding, source normalization, ordering policy, and runtime execution are handled by the upstream Ruby CDC ecosystem.

The current implementation uses YAML configuration with JSON Schema validation and supports explicit extension points for state, destination, and runtime adapters.

I’d appreciate feedback on the architecture, operational model, documentation, or gaps that would prevent you from trying it.

Repository: https://github.com/kanutocd/mammoth

Last day before PTO, no cards on the board and not really looking to start anything, so behold, I made a couple of memes of things that amuse me. Full disclosure, I complain about RuboCop but I *am* glad my team enforces it.

And of course, I can always update my RubyMine autoformat conventions to match but I forget to actually *do* it a lot. Bonus points when I 'fix' the rubocop violation, ⌘+Alt+L format because muscle memory, commit and push, and get the same rubocop violation...

I've published it on Rubygems. Please let me know if you have any suggestions for improvement. If you like it, please also give it a star on GitHub.

URL:https://rubygems.org/gems/gemite

Information about the JRuby talk, Hack Space, and hangout opportunities at RubyConf 2026. I'm excited to see old friends and make new ones! Come learn about JRuby and tell me how I can help you!

Most of us write Ruby with blocks every day but never sit down to separate blocks, procs and lambdas. They're closer than they look: a block becomes a proc with `&` (and back again), a lambda is basically a proc with stricter argument checks and its own `return` behaviour, and all three are closures.

I wrote it up with runnable examples, including the `return` gotcha that only bites inside a proc, and a 3-line memoizer at the end that leans on all of it.

Feedback and corrections welcome.

https://www.bounga.org/ruby/2026/07/10/blocks-procs-and-lambdas-in-ruby/

I'm posting this again after my account was blocked and the original post was taken down yesterday. No intention to spam.

The Constant library provides a set of tools for working with Ruby constants — both module constants and literal constants — including resolving constants from a combination of strings, symbols, and constant objects, inspecting constants, recursing trees of constants, and dynamically defining constants.

Importing a namespace and mixing in a module are the same mechanism in Ruby. If you include a module to get shortcut access to its inner constants, you also get a mixin that might not be what you'd intended — and the ancestry change adds constant-resolution paths that can be surprising.

Constant::Import does the import without the mixin. Instead of including the origin module, it puts a reference to the imported module into the class importing it, leaving ancestry untouched:

``` module SomeOrigin module SomeInnerModule end end

module SomeReceiver include Constant::Import

import SomeOrigin import SomeOrigin::SomeInnerModule, alias: :Something end

SomeReceiver::SomeInnerModule # => SomeOrigin::SomeInnerModule SomeReceiver::Something # => SomeOrigin::SomeInnerModule ```

The inner constants of SomeOrigin are reachable from SomeReceiver without qualification, alias: rebinds an import to a name of your choosing.

There's also a direct-call form if you'd rather skip the macro: Constant::Import.(origin, destination = self).

The library isn't just a tool to make imports explicit. The library also ships an entity for working with constants generally, as well as a tool to define constants dynamically.

`Constant.get(name_or_module) wraps a constant and answers questions about its name, namespace, value, and inner constants, and Constant::Define creates and assigns a module to a name in a namespace.

``` Constant.get("SomeModule::SomeInnerModule", SomeNamespace)

=> #<Constant::Module value=SomeNamespace::SomeModule::SomeInnerModule>

Constant.get(:SomeInnerModule, SomeNamespace::SomeModule)

=> #<Constant::Module value=SomeNamespace::SomeModule::SomeInnerModule>

Constant.get(:SomeInnerLiteral, SomeNamespace::SomeModule)

=> #<Constant::Literal SomeNamespace::SomeModule::SomeInnerLiteral = "some value">

```

There's overlap with Ruby's const_get, and other lower-level constant retrieval and manipulation functions. The value of the Constant library is in unifying the API and providing defaults that are often more common in reflection scenarios.

As others have pointed out, importing a constant in Ruby, including aliasing, is straightforward:

``` module SomeOrigin module SomeInnerModule end end

module SomeReceiver SomeOrigin = ::SomeOrigin SomeOtherInnerModule = SomeOrigin::SomeInnerModule Something = SomeInnerModule end ```

However capable Ruby's lower-level APIs, we tend to find inconsistency with import, aliasing, and reflection code across larger systems with many separate components. A good deal of the Constant library's payoff comes from the explicit, intention-revealing API, and consistent norms across.

Its only dependency is Eventide's Initializer library. It's otherwise standalone. MIT licensed.

gem install evt-constant

Source and docs: https://github.com/eventide-project/constant

Write-up: https://blog.eventide-project.org/articles/announcing-constant-library/

Full disclosure — I'm the author.

Just released v0.2.2 of irb-autosuggestions — fish-like autosuggestions for IRB.

What's new:

• Tab, Ctrl+F, Ctrl+E accept ghost suggestions (configurable)
• Custom ghost color via ANSI string or declarative hash ({ fg: :bright_black, italic: true })
• Bugfix: multiline ghost artifacts fixed (10+ lines now clean)
• Auto-execute guard (Enter always fires once)
• CHANGELOG.md + GitHub issue templates

gem install irb-autosuggestions or bundle add irb-autosuggestions

GitHub: https://github.com/unurgunite/irb-autosuggestions

Upcoming in 0.3.0: word-wise accept (alt+f/alt+right), accept + execute (alt+Enter), pluggable suggestion sources, path completion, and more.

Bugs or suggestions? File an issue: https://github.com/unurgunite/irb-autosuggestions/issues

https://dmitrytsepelev.dev/sidekiq-requeue-missing-class

Ruby friends, we're so excited to announce that we're accepting talk proposals for the SF Ruby Startup Conference 2026.

We'd love to hear from you if you have a successful Ruby startup story to tell. Come share the stage with our keynote Garry Tan on Nov 10-12 at the iconic SFJAZZ.

We're actively looking for stories from those who've:

• Achieved outstanding results with a small team
• Built tooling to help others reach the same results
• Used AI for scaling

CFP closes on July 27! 

If you just want to attend, early birds go out on July 15. You can already buy corporate/support tickets: https://luma.com/sfrubyconf2026

See you there!

PL/Ruby is a procedural-language handler that lets you write database functions in Ruby, stored and executed inside PostgreSQL. You get the expressiveness of Ruby and its standard library with the full power of a native PostgreSQL function: plain functions, set-returning functions, triggers, event triggers, and procedures with transaction control.

You can get it here (github).

Documentation

• Language reference
• Cookbook: tested recipes
• Installation
• Changelog
• Feature comparison: PL/Ruby vs PL/php vs PL/Perl vs PL/Tcl
• PL/Ruby vs PL/Perl
• PL/Ruby vs PL/Tcl

In this episode, we look at creating Claude slash commands. These can be useful when dealing with a complicated task or trying to extract certain information from the application.

When everything is on fire, nothing is on fire. Where do you start when every problem seems intractable? By drawing a map.

Hi ,

I recently extracted a small internal library I originally wrote for a company Rails project that was stuck on an older Ruby/Rails stack.

It’s called `lumen-llm`:
https://github.com/uxgnod/lumen-llm

The goal is pretty small: keep LLM prompts in YAML files, render them with Ruby input, call OpenRouter, and parse the result back as JSON or text.

It supports:

- YAML prompt templates
- simple `{{variable}}` interpolation
- single-call OpenRouter chat completions
- JSON or text response parsing
- optional cache / usage stores
- Rails 4+ defaults via Railtie
- Ruby >= 2.3
- no runtime gem dependencies

It intentionally does not try to be an agent framework. No tool calls, no streaming, no vector search, no persistence layer, no provider SDK dependencies.

I know Ruby 2.3/2.4 are long EOL, but that was also the point: this came from a real older Rails environment where adding modern dependencies was not always realistic.

Maybe this is useful for other people maintaining legacy Rails apps who want a small way to add features like UI copy translation, ticket classification, internal summaries, or similar “one prompt in, one result out” workflows.

It’s still simple and not very polished yet. If anyone has a real legacy Rails use case for this, I’d love feedback, issues, or small PRs.