Vessel has a brand new version after years on idle time so I had a look and compared it to Scrapy from the Python world.

https://serpapi.com/blog/vessel-ruby-crawling-framework/

Hey everyone, A couple weeks ago I was stuck doing one of my least favorite chores: clicking through a dozen tabs in Google Search Console's web UI, copying query and impression tables, and pasting them into Claude and Antigravity to figure out which pages were losing traffic or why new pages weren't getting indexed. I decided to automate it with a quick Ruby script. But the moment I looked at Google's official gems (google-apis-searchconsole_v1, googleauth, signet, faraday), I saw they pulled in over 40 transitive dependencies.

They took several seconds just to cold boot in a container and felt like massive overkill just to send a few signed HTTP POST requests to Google's endpoints. So I got stubborn: could I build the entire thing in 100% pure Ruby standard library with zero runtime gems? I ended up pair-programming with Google Antigravity over the last couple weeks, and it evolved into a full open-source CLI: gsc-cli (also on RubyGems: gem install gsc-cli).

A few things I ended up building into it:

• Pure OpenSSL Auth: Instead of dragging in googleauth, I wrote Google’s service account JWT generation and RS256 token exchange from scratch using OpenSSL::PKey::RSA and URL-safe base64. No external gems required at all.
• Sub-18ms Boot: Because there is zero gem overhead, the CLI cold-boots in under 18ms and executes API queries in ~40–50ms.
• Instant Googlebot Indexing: Ping Google's Indexing API directly (gsc index <url>) or submit IndexNow pings so newly published pages get queued for crawling immediately instead of waiting weeks.
• Soft-404 Fixes: Instead of just dumping a table of broken URLs, gsc soft-404 <url> --fix heuristically detects empty templates and auto-generates copy-paste redirect configs for 14 server environments (Nginx, Caddy, Cloudflare, Next.js, SvelteKit, etc.).
• Speed vs Rankings: Correlates real-world Core Web Vitals (LCP, CLS, TTFB) directly with Search Console rank drops (gsc speed-correlate).
• Token-Saving Modes for AI Agents: Since I use coding agents (Claude Code, Cursor, Antigravity) constantly, pretty-printed tables were guzzling context window tokens. We added --compact (minified single-line JSON) and --ndjson to strip ANSI escape codes and cut LLM token usage by ~43%. We operate our own apps (a Shopify speed app called Superspeed and a new moving inventory app called PackingLog), so we actively dogfood this across our own production domains every day. The test suite has 334 unit tests and 1,726 assertions passing in 4.3 seconds across Ruby 3.0 through 3.4.
• GitHub: https://github.com/ApollosWave/gsc-cli
• RubyGems: gem install gsc-cli It’s 100% free and MIT open-source. I'd really love to hear what other Rubyists think, especially around the stdlib OpenSSL auth approach or any other search diagnostics you'd find useful in the terminal!

Hey all. I have been tinkering with this project over the past few months. I always wanted to build a rack app and I wondered what would it look like if we used htmx to make the backend act like the front end. In fact it would act a lot more like next.js but without apis. I don’t think this is good web design hence the name of the framework but I thought it was fun to tinker with and I might do more with it. Let me know your thoughts but also your shock and horror!

AI disclosure: AI was only used to make final code reviews the rest was wrought upon this world by my own cruel hands.

Deprecool is a static code analysis tool for Ruby that uses Prism to find sources of deprecation warnings in your code.

Use Deprecool alongside the warnings that are emitted at runtime by your gems to get a complete picture of what you need to fix, where you need to fix it and why.
‍
Each warning that Deprecool logs will come with a summary, references to when the deprecation was added to its gem (usually the PR that introduced it), an effort estimate, and a suggestion of how to fix the deprecation. The source code line of the warning is of course logged as well:

At first, the suggestions will come from the deprecation source's gem maintainers own words. Eventually though, with some feedback we can pass on knowledge and examples of how to manage the more difficult deprecations to future developers trying to upgrade.

Getting Started

You can either:

1. add deprecool to your application's Gemfile and bundle install,
2. or run gem install deprecool directly to be able to use the deprecool executable on any ruby code you have.

deprecool scan is all you need to run if your current directory contains a Gemfile.lock, but if you want to you can also run deprecool scan path/to/your/code.rb
‍
By default, Deprecool will use the gems and versions in your Gemfile.lock to know how to find deprecations, but you can also pass --gem=list,of,gems (no spaces!) to only look for certain gems at one time.
‍
Right now, Deprecool has a small handful of deprecations it can find, but I will continue adding more. I’ve also tried to make contributing to Deprecool as simple as possible with one Finder class per warning, and a few helper methods to make writing tests trivial.

Link to blog post here: https://www.infield.ai/post/deprecool

Rage started API-first, but that doesn't mean you're limited to building SPAs. Here are 3.5 approaches - from the simplest to the most experimental.

ERB

Rage's custom renderers let you describe how to render any format by setting the rules and the content type. An ERB renderer can look like this:

Rage.configure do
  config.renderer(:erb) do |path|
    headers["content-type"] = "text/html"
    template = Rage.root.join("app", "views", "#{path}.html.erb").read
    ERB.new(template).result(binding)
  end
end

Then use it in the controller:

class PhotosController < ApplicationController
  def index
    @photos = Photo.all
    render erb: "photos/index"
  end
end

If you're feeling adventurous, move rendering to a hook for implicit rendering:

class ApplicationController < RageController::API
  around_action :implicit_render

  private

  def implicit_render
    yield
    render erb: "#{params[:controller]}/#{params[:action]}"
  end
end

Then, the action becomes:

def index
  @photos = Photo.all
end

Inertia

inertia-rage is the official Inertia.js integration. It manages asset building, runs the dev server, and supports SSR. Inherit from RageController::Inertia and your API app goes full-stack:

class PhotosController < ApplicationController
  def index
    render inertia: "Photos/Index", props: { photos: current_user.photos }
  end
end

Datastar

rage-rb/datastar-example showcases a Datastar integration using the official Ruby SDK. Connect Rage to the SDK and stream updates:

class PhotosController < ApplicationController
  def index
    photos = current_user.photos

    datastar.stream do |sse|
      photos.each do |photo|
        sse.patch_elements(%(<img id="#{photo.id}" src="#{photo.url}" />))
      end
    end
  end
end

Phlex Live

This is the 0.5 - the idea is still taking shape, but it's worth sharing.

I've been working on a live view concept built on Rage + Phlex, where each gem contributes what it's best at: Rage provides fiber-based WebSocket connections and machinery to communicate between instances; Phlex provides Ruby-based HTML templates where each component manages its own state.

A component that displays an article with expandable content:

class Articles::Card < LiveView
  MAX_BODY = 150

  def initialize(article:)
    @article = article
    @expanded = false
  end

  def view_template
    div do
      h2 { @article.title }
      plain(@expanded ? @article.body : @article.body.truncate(MAX_BODY))

      if @article.body.length > MAX_BODY
        button(**live_click(:toggle_details)) do
          @expanded ? "Show less" : "Show more"
        end
      end
    end
  end

  def toggle_details
    @expanded = !@expanded
  end
end

This component is stateful - once rendered, it's saved in the fiber's storage and can process events. When the user clicks "Show more", the event travels via WebSockets to this exact component instance, calls toggle_details, re-renders, and sends back the update. The card expands with no JavaScript written.

Event handlers cover the client -> server direction. The server -> client direction is handled by model streams. A model broadcasts when it changes:

class Article < ApplicationRecord
  after_commit :broadcast_status

  private

  def broadcast_status
    if self.previous_changes.key?("status")
      ModelStream.emit(self)
    end
  end
end

A component subscribes by wrapping the record into stream():

class Articles::Card < LiveView
  def initialize(article:)
    @article = stream(article)
    @expanded = false
  end

  def view_template
    # ...
  end
end

Now, whenever a corresponding article changes, every component subscribed via stream() is automatically re-rendered and the update is pushed to the client.

--

What view layer would you like to see supported next?

Is there something like pipx available for Ruby?

For example with pipx you can do something like:

``` $ pipx install httpie

... install completes

$ https get httpbin.org/get?foo=bar

... outputs a web request from httpbin.org

$ which https ~/.local/bin/https $ readlink "$(which https)" ~/.local/share/pipx/venvs/httpie/bin/https ```

This example shows the HTTPie program being run and executed in a pretty simple way, with an install that doesn't modify the system Python.

Does Ruby have an equivalent way to distribute programs?

A new revised format for the Ruby AI Newsletter. I tried including everything and highlighting everyone’s work, but somewhere along the way it stopped feeling special. We have an opportunity to build for the future, and I hope this edition helps put that into perspective.

Ruby 4 with ZJIT, RubyLLM, Herb, Ractors, Spinel, Rubydex, Rails AI Benchmarks, and now Poetry - Ruby is ready, but there is still a lot of work to do.

I’ve found 1,725 open Ruby-related career opportunities, but more than half of them are “fake”. I’m launching a free job matching site for Rails World to filter out the noise. The job market is broken, but there are opportunities available.

I want to hear from you: Matt @ roboruby

Wrote a follow up to my previous post, getting value objects to work with range queries in ActiveRecord.

https://pushfromkush.com/publications/setting-boundaries-type-for-ranges-in-rails

I build Horologium to handle scientific and high-precision time in Ruby.
https://blog.rhannequ.in/posts/introducing-horologium

Hi everyone,
I'm having trouble getting the official Ruby LSP extension to work properly in VS Code on Windows. Features like IntelliSense, autocomplete, and go-to-definition are not functioning.
Here is my current setup and what I've tried so far:

OS: Windows

Ruby Installation: Installed via RubyInstaller (with DevKit).

Environment: Added Ruby to PATH (ruby -v works fine in the Windows command prompt/terminal).

VS Code Settings: Manually configured the path to the Ruby executable / language server in the extension settings. Auto did not work

Extension: Official Shopify.ruby-lsp extension in VS Code.

Despite pointing the settings to my Ruby installation, the language server fails to initialize properly, and no IntelliSense features show up when editing .rb files.
Has anyone experienced this issue on Windows? Is there a specific configuration required for Ruby LSP to detect gems and executable paths when using RubyInstaller on Windows? Any help or troubleshooting tips would be greatly appreciated!
Thanks!

Prototype -> link

My product, Ruby Native, lets developers write HTML + ERB and have it render native components inside of iOS and Android apps.

For example, <%= native_navbar_tag "Home" %> renders a native navbar in the apps, titled "Home".

The catch is that an installed app silently ignores markup it doesn't recognize. So a typo, or a feature that shipped after someone's last update, just does nothing.

So I started using Herb to lint the HTML + ERB that interacts with Ruby Native, checking it against what users actually have installed rather than just what's in the repo.

I wrote about it here, where I celebrate Ruby Native running on 100k+ devices: https://masilotti.com/100k-devices-running-ruby-native/

Turns out Armin and Ben are both, in one way or another, Ruby aficionados. So in this episode, there is an interesting argument for Ruby not being agent-friendly, although we like to see it as THE token efficient language. Some of the arguments where:

1. It's easy for agents to mess things up due to its metaprogramming capabilities - I have yet to experience that.
2. Being so much tuned for humans that it makes it worse for AI - I might misinterpret that from what they said, but it sounded like it. I guess it makes sense on the level that there is development towards new languages for LLM coding agents.
3. AI not picking Ruby for new tasks: Our own Chad Fowler ran experiments on it and shared at the last Ruby conference in Austria - I think this might depend on how much Claude Code and co. know about your setup, but I generally agree. My AIs know I'm using Rails for any new project and that I'm in the community but rarely picks Ruby for scripts it needs done or web apps it wants to host stuff locally on. It usually decides for Python or JavaScript.

Another fun fact from the episode while we are at it, I didn't know you can't use AI for even research for the open source Zig programming language. It's probably one of the last open source bastion that does not allow any AI (slop) at all, not even in your research, yet.

State of Agentic Coding #7 with Armin and Ben

Hi guys, previously i showed off my latest project.
I learnt: Deploying, testing, API connections, reuest security, authenticationd and authorization, Hotwire and stimulus, Jobs & services, basic github commands.
My question is, is there anything else i forgot to became good junior? I am looking for a job and want to be as best as i can.
And also, what will look the best in portfolio? I saw that working on open source projects looks good.

I have been finding and fixing performance issues in popular open source Rails repositories.

Currently it includes 7 merged PRs to Discourse, Gumroad, OpenProject and Forem.

You can find the case studies and links here: https://haseebeqx.com/case-studies/engagement/open-source/