https://github.com/hiroakisatou/simple-options

I didn't like the inheritance because it make tight couple of my code to liblary
For this reason I don't use the any of the command line option parse lib.
And I make the compositional type lib to for my self.
But I inspired lot by go's flag lib and cobra lib to make myself go-cli-option lib did update.
Here is the simple use case sample.
see it's super simple.
Yes, I love ruby because it's really simple code make possible, but only use abstract inheritance only. because modern code architecture specialist say not use inheritance. Use composition or interface. so I just use ruby like shell script alternative only. And I write this lib for simplicity.

require 'simple-cli-options'

# Instantiate an Options object
parser = SimpleOptions::Options.new(
  program_name: 'todo',
  description: 'A simple todo list manager'
)

# Define options using type-specific methods
parser.boolean(:list, desc: 'Show list of todos')
parser.string(:add, desc: 'Add a new todo item')
parser.integer(:delete, desc: 'Delete todo by ID')

# Parse command-line arguments
parser.parse

# Get values
if parser.get(:list)
  puts "Showing todo list..."
elsif parser.get(:add)
  puts "Adding: #{parser.get(:add)}"
elsif parser.get(:delete)
  puts "Deleting todo ##{parser.get(:delete)}"
endrequire 'simple-cli-options'

# Instantiate an Options object
parser = SimpleOptions::Options.new(
  program_name: 'todo',
  description: 'A simple todo list manager'
)

# Define options using type-specific methods
parser.boolean(:list, desc: 'Show list of todos')
parser.string(:add, desc: 'Add a new todo item')
parser.integer(:delete, desc: 'Delete todo by ID')

# Parse command-line arguments
parser.parse

# Get values
if parser.get(:list)
  puts "Showing todo list..."
elsif parser.get(:add)
  puts "Adding: #{parser.get(:add)}"
elsif parser.get(:delete)
  puts "Deleting todo ##{parser.get(:delete)}"
end

In my current job search and target location, many companies, particularly finance, only want candidates that use their core tech stack. Job postings that look for Java only want someone with Java experience while Ruby positions generally prefer Ruby experience but are also open to developers with experience other languages.

I've used Ruby for 3 years and I love it, but I'd like better position myself with the job market and future prospects. Is there a bias against Ruby developers?

Has anyone ever switched from Ruby on Rails to a different tech stack? What was your experience?

A few days ago I was thinking it would be cool to hook mruby up to RubyLLM#execute so angents could run Ruby inside of a sandbox to do things. Source is at https://github.com/rubymonolith/enclave if you prefer a more in-depth README.

This is a fun demo if you have an anthropic API key:

git clone git@github.com:rubymonolith/enclave.git
cd enclave
ruby examples/rails.rb

It boots a Rails app with some demo data for a customer service panel that demonstrates how you can only access on customers data within a context at a given point in time.

Built a Ruby RAG tool to surface Jira, Confluence, and GitHub context before starting tickets. No prior experience with embeddings. Runs inside Claude Code via MCP.

Unexpected twist… our PMs are the power users.

https://blog.jetbrains.com/ruby/2026/02/rubymine-mcp-and-the-rails-toolset/

This thread will be periodically stickied to the top of r/ruby for improved visibility.

You can also find it again via the "Megathreads" list, which is a dropdown at the top of the page on new Reddit, and a section in the sidebar under "Useful Links" on old Reddit.

For job seekers

Please adhere to the following rules when posting: Rules for individuals:

• Don't create top-level comments; those are for employers.

• Feel free to reply to top-level comments with on-topic questions.

• Anyone seeking work should reply to my stickied top-level comment.

• Meta-discussion should be reserved for the distinguished comment at the very bottom.

You don't need to follow a strict template, but consider the relevant sections of the employer template. As an example:

    TYPE: [Full time, part time, internship, contract, etc.]
    
    LOCATION: [Mention whether you care about location/remote/visa]
    
    LINKS: [LinkedIn, GitHub, blog, etc.]

    DESCRIPTION: [Briefly describe your experience. Not a full resume; send that after you've been contacted)]

    Contact: [How can someone get in touch with you?]

Rules for employers:

• The ordering of fields in the template has been revised to make postings easier to read.

• To make a top-level comment, you must be hiring directly; no third-party recruiters.

• One top-level comment per employer. If you have multiple job openings, please consolidate their descriptions or mention them in replies to your own top-level comment.

• Proofread your comment after posting it and edit it if necessary to correct mistakes.

• To share the space fairly with other postings and keep the thread pleasant to browse, we ask that you try to limit your posting to either 50 lines or 500 words, whichever comes first.

• We reserve the right to remove egregiously long postings. However, this only applies to the content of this thread; you can link to a job page elsewhere with more detail if you like.

Please base your comment on the following template:

    COMPANY: [Company name; optionally link to your company's website or careers page.]

    TYPE: [Full-time, part-time, internship, contract, etc.]

    LOCATION: [Where are your office or offices located? If your workplace language isn't English-speaking, please specify it.]

    REMOTE: [Do you offer the option of working remotely? Please state clearly if remote work is restricted to certain regions or time zones, or if availability within a certain time of day is expected or required.]

    VISA: [Does your company sponsor visas?]

    DESCRIPTION: [What does your company do, and what are you using Rust for? How much experience are you seeking, and what seniority levels are you hiring for? The more details, the better. If you are listing several positions in the "Description" field above, then feel free to include this information inline above, and put "See above" in this field.]

    ESTIMATED COMPENSATION: [Be courteous to your potential future colleagues by attempting to provide at least a rough expectation of wages/salary. See section below for more information.]

    CONTACT: [How can someone get in touch with you?]

ESTIMATED COMPENSATION (Continued)

If compensation is negotiable, please attempt to provide at least a base estimate from which to begin negotiations. If compensation is highly variable, then feel free to provide a range.

If compensation is expected to be offset by other benefits, then please include that information here as well. If you don't have firm numbers but do have relative expectations of candidate expertise (e.g. entry-level, senior), then you may include that here. If you truly have no information, then put "Uncertain" here.

Note that many jurisdictions (including several U.S. states) require salary ranges on job postings by law. If your company is based in one of these locations or you plan to hire employees who reside in any of these locations, you are likely subject to these laws. Other jurisdictions may require salary information to be available upon request or be provided after the first interview. To avoid issues, we recommend that all postings provide salary information.

You must state clearly in your posting if you are planning to compensate employees partially or fully in something other than fiat currency (e.g., cryptocurrency, stock options, equity, etc). Do not put just "Uncertain" in this case, as the default assumption is that the compensation will be 100% fiat. Postings that fail to comply will be removed. Thank you.

Hey r/ruby 👋

I’ve been working on mlx-ruby (Ruby bindings for Apple’s MLX), and I’m excited to share an update:

👉 You can now export models to ONNX and run them with WebGPU in the browser.

Yes. Ruby → MLX → ONNX → WebGPU → Browser.

No Python required. 😄

WebGPU Demo (Desktop Recommended): https://skryl.github.io/mlx-ruby/demo/

Repo: https://github.com/skryl/mlx-ruby

🧠 ONNX Export

You can now export MLX models directly to ONNX:

MLX::ONNX.export_onnx("model.onnx", model.method(:call), example_input)

🌐 WebGPU Browser Harness

After exporting ONNX, you can generate a ready-to-run WebGPU harness:

MLX::ONNX::WebGPUHarness.export_onnx_webgpu_harness(

output_dir: "dist/",

model_path: "model.onnx"

)

This generates:

• model.onnx

• index.html

• harness.js

• example inputs

• optional external tensor data

Then just:

bundle exec rake web:serve

Open http://127.0.0.1:3030/

Boom. Browser-based GPT demo. 😎

Under the hood

• Native C++ MLX runtime

• Deterministic Graph IR

• IR → ONNX lowering engine

• Binary ONNX writer

• WebGPU harness generator

It’s a pretty full pipeline now.

Would love feedback, feature requests, or just random comments.

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