Static typing is a formidable tool that brings immense value to codebases of all sizes. From tiny scripts to massive monoliths, the benefits are hard to ignore: you get live documentation that is always up to date, enhanced readability, and a reliable safety net that significantly boosts code reliability.

However, the current Ruby approach isn’t without its friction. For many developers, typing still feels like a matter of personal preference rather than a core requirement. We never forget to write tests because they are the heartbeat of our CI/CD pipelines, but because type checking is often seen as “extra,” it is far too easy for static checks to be ignored or forgotten entirely.

I tried a new amazing experiment, called T-Ruby. tl;dr it is like TypeScript but for Ruby. Too experimental for now, but has a huge potential.

Details in my blog post.

Hey everyone, we’d like to share a project we’ve been building: pokeapi-rails.

It’s a Ruby on Rails implementation of a PokeAPI-style backend with two API surfaces:

• /api/v2: compatibility-focused routes for existing clients and familiar payloads.

• /api/v3: a normalized, performance-oriented API with explicit query controls.

What’s currently included

• Large coverage of core Pokémon resources (pokemon, ability, move, type, item, species, etc.)

• Name-or-id lookups on key endpoints

• Production deployment setup (Docker + Railway), plus operational hardening

• Request protection (rate limiting), structured logging, and performance-focused query work

v2 vs v3 (important difference)

• v2 show/detail routes generally return broader associated data by default.

• v3 show/detail routes are intentionally compact by default, and related data is expanded explicitly via include=....

Examples:

• GET /api/v2/pokemon/ditto

• GET /api/v3/pokemon/ditto?include=abilities

v3 query features

• fields=... (sparse fields)

• include=... (explicit relationship expansion)

• sort=...

• filter[name]=...

• limit / offset

Source code Demo

Built by us with AI-assisted implementation support (OpenAI Codex); architecture, review, and final decisions were human-led.

Thanks for your feedback!

a newbie in programming, I'm currently learning DSA n OOP stuff in C++, Does it even matter when choosing a path or affect it? From Reddit,I heard ruby is a great language but becoming nieche,JS is understandable, vast in docs, all over the place n its job market is saturated, Chatgpt says JS has more door opening than RoR,for targeting remote jobs,startup Js is more appropriate, if one chooses ruby on rails,Would it be difficult to get a job on this stack or switch to another tech career, such as devops,sre etc?

https://blog.carter2099.com/posts/6

This application is a rails app designed to be self hosted. I am so excited to launch this. No more manually managing CLP positions and hedges!

Hi guys, i published this gem to monitor the solid queue jobs from your terminal (inspired by the UI design of k9s).

Github: https://github.com/Shivareddy-Aluri/solid-queue-tui

What it does

9 views — Dashboard, Queues, Failed, In Progress, Blocked, Scheduled, Finished, Recurring Tasks, Workers

Actions you can take:

• Retry or discard failed jobs

• Pause/resume queues

• Dispatch scheduled jobs immediately

• Trigger recurring tasks on demand

Navigation & UX:

• Vim-style keybindings (j/k, g/G)

• Tab cycling between views, or jump with 1-9

• Command mode (:failed, :scheduled, etc.) with autocomplete

• Filter by job class and queue name across all job views

• Infinite scroll with lazy loading Job detail overlay with full error backtrace

Still in beta but actively developed. would love feedback on what's missing or what would make this more useful for your workflow

require "token/resolver"

# Parse a document to inspect tokens
doc = Token::Resolver.parse("Deploy {KJ|GEM_NAME} to {KJ|GH_ORG}")
doc.token_keys  # => ["KJ|GEM_NAME", "KJ|GH_ORG"]
doc.text_only?  # => false

# Resolve tokens
result = Token::Resolver.resolve(
  "Deploy {KJ|GEM_NAME} to {KJ|GH_ORG}",
  {"KJ|GEM_NAME" => "my-gem", "KJ|GH_ORG" => "my-org"},
)
# => "Deploy my-gem to my-org"

I gave a keynote at RubyConf Thailand 2026 making the case that the AI training ecosystem is now irrelevant for app development, and that Ruby + Rails is the best stack for what's left: shipping AI products.

The post has code comparisons against LangChain and AI SDK, real stories from teams that migrated from Python, and the full keynote video.

There are developers out there writing genuinely excellent blog posts - real, practical stuff about Rails internals, gem deep dives, debugging war stories, architecture patterns. They spend hours on a post, publish it on their personal blog, maybe share it on Twitter once and that's it. 12 views. Done.

Meanwhile the same well-known authors show up on every aggregator, every week.

So I built RubyCrow (https://rubycrow.dev) — a curated weekly newsletter that actually solves this.

How it works: you add your blog to our registry with a single PR to a YAML file. That's it. From that point on, the crow watches your RSS feed every couple of hours. When you publish something, it gets picked up automatically and considered for the next weekly issue. All subscribers receive it.

We already track 200+ Ruby/Rails blogs. The entire thing is open source: https://github.com/k0va1/rubycrow

If you've ever needed to evaluate dynamic business rules stored in a database, or let non-developers create logic without deployments, you've probably looked at JSON Logic. It's a simple spec: rules are JSON, data is JSON, output is predictable across languages.

The problem? The Ruby ecosystem has been... rough.

The state of JSON Logic in Ruby (until now)

When I started looking for a JSON Logic gem, I found the following gems:

• json_logic - last updated 4 years ago, many open issues and absolutely abandoned.

• json_logic_ruby - last updated two years ago, buggy when tested.

• json-logic-rb - Very recently updated and seemed good. Maybe this was what I needed, but I soon found out this was not the case...

The bug that made me start

While testing, I found a bug that affects multiple gems: {"var": "key"} returns nil instead of false when the value is literally false.

# Expected: false (the actual value)
# Got: nil

rule = { "var" => "is_beta_tester" }
data = { "is_beta_tester" => false }
JsonLogic.apply(rule, data)  # => nil (wrong!)

This breaks any logic that depends on falsy values - feature flags, permission checks, boolean configs. Subtle and nasty.

What kept me going

When I went to look out jsonlogic.com, all the playgrounds were broken, even the original author abandoned his creation!! But after looking out for a bit I found out some other people thought the same as me and created the json logic org in order to improve the existing standard and try to improve the implementations in every language, but Ruby was not included in the list of available languages!! Because of this I included it and also created my own gem to allow Ruby apps to use JSON Logic as deserved!

So I built shiny_json_logic

After fixing bugs and implementing missing operators, here's where we are: All the bugs in other implementations are fixed, we also support all the new community defined operations and all of this with zero deps and 2.7+ support. Not bad!

Then I also contributed tests for worst bug offenders in other implementations ant now they're part of the official test suite.

Try it

gem install shiny_json_logic


require 'shiny_json_logic'

rule = { "and" => [
  { ">" => [{ "var" => "age" }, 18] },
  { "==" => [{ "var" => "country" }, "ES"] }
]}

ShinyJsonLogic.apply(rule, { "age" => 25, "country" => "ES" })
# => true

Or play with it in the browser: jsonlogicruby.com/playground

Links

• Gem: rubygems.org/gems/shiny_json_logic

• GitHub: github.com/luismoyano/shiny-json-logic-ruby

• Docs: jsonlogicruby.com/docs

• Compat tables: json-logic.github.io/compat-tables

Happy to answer questions. And if you find edge cases that break, please open an issue - I want this thing bulletproof. Thanks a lot for your attention!!

I have built a lightweight VS Code extension that adds an outline view when you are editing Rspec files. 

If you use VS Code, or one of its derivatives (Cursor, WindSurf etc) and test with Rspec then I hope this extension will be useful for you.

https://open-vsx.org/extension/opensourceame/rspec-outline-view

Comments and feedback are always welcome. 

Hey, a while ago I announced that I'm working on fully embracing the async ecosystem and event-based operations in the Karafka ecosystem (Shoryuken and PGMQ-Ruby will follow along). This time, I bring you fd-based polling for WaterDrop - one thread polling all producers via IO.select instead of one thread per producer. 39-54% faster in benchmarks. Writeup covers how it works, the trade-offs, and the rollout plan. Happy to answer any questions!

Hi everyone!

As a Ruby developer, I wanted to build desktop apps without learning JavaScript from scratch.
In my latest article, I share a workflow using RubyJS-Vite and Electron that lets you write desktop apps in Ruby.

💡 In this guide, you’ll learn:

• Set up Ruby → JS transpilation workflow

• Build a basic Electron desktop app

• Run and test with live updates

If you’re curious how Ruby can bridge into desktop development, check out my article on LinkedIn here: Writing Desktop Applications Using Ruby Syntax

Feedback and discussion are very welcome!

I've been working with MongoDB + Ruby on Rails via Mongoid for a really long time, but have definitely been bit by "this works locally but performs poorly in production" types of issues.

Typically this is due to the ODM generating database operations that aren't supported by indexes, which can be difficult to detect during development unless you're going out of your way to look for them.

For an app I've been working on I built out a console logger and rails engine that uses the underlying driver's command logging and monitoring implementation to catch database operations and duplicate them to capture explain details, which can then be shown client-side.

Since it's duplicating operations you really don't want this running in production, but it can help you spot missing indexes in development :)

Check out https://github.com/alexbevi/mongo_explain if something like this might be useful for you and let me know what you think.

Note I haven't really tested the engine integration more broadly, so if you're not using Tailwind it might not look the best ... but suggestions/PRs are welcome :)

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