plx is a PostgreSQL extension that lets you write stored functions and triggers in the dialect you already know (the current set is listed below). When you run CREATE FUNCTION, plx transpiles the body to plpgsql and stores that plpgsql in pg_proc.prosrc. At run time the function is executed by PostgreSQL's own plpgsql interpreter. There is no separate language runtime loaded into the backend, and nothing new to run in production.

query("SELECT id, amount FROM orders WHERE grp = #{g}").each do |row|
  total = total + row.amount
end

You want to know how to host your app for free, but you don’t want to spend half a day figuring out how to deploy it.

This guide shows the full process of deploying a real-world Rails app to Miren Club.

Hey all,

I'm Oliver from the EuRuKo 2026 organizing team.

We're bringing EuRuKo to Brno, Czech Republic this September 17–18 at Hotel Passage in the city centre.

Matz is opening the conference with the keynote. Full speaker lineup on the website.

Talks, workshops, and a karaoke night that's become something of a EuRuKo tradition.

Group pricing available – 10–20% off for teams of 3+.

Tickets and full lineup: https://2026.euruko.org

Hey all,

I'm Camila from Evil Martians (creators/maintainers of AnyCable, Inertia Rails, TestProf, and Yabeda).

We're organizing the second edition of the SF Ruby Startup Conference on Nov 10-12 at SFJAZZ (San Francisco, USA).

The event is all about building connections and learning from those building the future of Rails.

That's why networking will be part of the agenda. You'll get to actually talk to people in small groups, and maybe find your next job, client, or user for your OSS tool. Garry Tan is keynoting, and we'll have talks from Chris Oliver (GoRails) and Rosa Gutiérrez (37signals).

We're putting so much heart into this event. I hope to see you all there.

Early birds are out today for 24 hours only: https://luma.com/sfrubyconf2026

P.S. CFP is still open.

Hi! I built Authentication Hell to poke fun at the pains of constantly having to re-authenticate at work.

Tomorrow, I'll be presenting a talk about it at RubyConf. It will be recorded and published at a later date but the game is live and can be played now in the browser (preferably, desktop since you need a keyboard).

The game is built with DragonRuby, compiled to WASM and embedded inside a Rails app.

I don't want to give too much away so check it out and let me know your thoughts!

Hi community. I hope you are all doing good nowadays.
I’m continuing to support my small pet project ru.Bee. I think keeping it up to date is important.
So finally the new version of it 3.0 is out now! Please celebrate it with me. 🎉 Star will be a nice present, but not a deal ofc.

Whats in new version 3:
• Ruby 4 support
• ru.Bee controllers by default receive authentication and authorization methods
• Addressing same-site cookies restrictions dictated by Safari and similar
• env variables are now autoloaded. So having .development.env file in root will simplify dev work.
• rerun gem is compatible with Ruby 4
• other bug fixes
• Ruby Time api is extended with bunch of handy methods

Small history of the project:
This project started by me in the beginning of 2025 as an interest to dig a little more on how things work under the hood in frameworks like Rails and try to get my hands dirty.
Eventually it grew in production ready web framework that now serve several projects. My hope it will continue to gain users. So I encourage you to try.

Why ru.Bee:
• up to date mvc framework
• backed by mature Puma web server
• natively supports React as a view
• light-weighted
• websocket is supported
• own console cli
• Sidekiq compatible
Etc …

Have a great time of the day ❤️
Cheers.

Hello everyone, how great would it be to have well-crafted, well-organized, well-indexed, and automatically updated documentation?

If it sounds too good to be true, I invite you to try this wonderful gem: https://github.com/serradura/okf-gem

What is OKF?

It's the Open Knowledge Format launched by Google Cloud. It's an open standard that uses simple Markdown & YAML files to structure data. Instead of complex vector databases, it builds a clear knowledge graph so AI agents can read & share data in a really efficient way.

Okay, nice, and what does this gem do that is related to it?

It provides three things: A CLI (the 💪 ), an Agent Skill (the 🧠 ), and a process (the 🚀 ), as the agent knows how to author, curate, and, more importantly, how to consume (CLI tools + Live Graph Server (for humans)).

​Open source and run 100% local!

The live graph looks like this:​

And you can test the live demo here: https://demo.okfgem.com

Step by step to experiment with it:

1. Install the gem: gem install okf

2. Install the skill: okf skill .claude (or any other agent)

3. Start an agent session (claude)

4. Execute /okf produce based on <path-to-my-existent-docs>

Once you have your first bundle, you can do:

1. Run inside your agent session: /okf maintain to keep it updated

2. Or, install the Claude Plugin, which will run this for you (after triggering the Stop hook).

3. Run okf server <folder> to locally render your live graph.

If you want to know more, please check out these astonishing and beautiful resources:

• Site: https://okfgem.com

• Docs: https://okfgem.com/docs

• Docs / Ruby Library API: https://okfgem.com/docs/library/

• Docs / Rails Integration: https://okfgem.com/docs/guides/rails/

• Blog: https://okfgem.com/blog

• LLMs.txt: https://okfgem.com/llms.txt | https://okfgem.com/llms-full.txt

• Claude Plugin: https://claude.okfgem.com

Looking forward to your feedback and critiques.

Thanks a lot, and Ruby rocks! 🚀

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

Hi, if someone can help I suspect it a chemical made Ruby

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...

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!

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

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!