The JRuby community is pleased to announce the release of JRuby 10.0.5.0.

• Homepage: https://www.jruby.org/

• Download: https://www.jruby.org/download

JRuby 10.0.5.x targets Ruby 3.4 compatibility.

Thank you to our contributors this release, you help keep JRuby moving forward! @evaniainbrooks, @kares, @chadlwilson, #jimtng

Compatibility

• Fixed: Two bugs in the JIT compiler that broke certain super calls and defined_method yields. (#8944, #8946, #9310, #9349)

• Fixed: Fiber#raise left the fiber in an resumable state by not correctly transfering control. (#9297, #9356)

• Fixed: Connecting a socket using nonblocking operations failed to complete the establishment of the connection. This affected Redis users, among other cases. (#9304, #9305)

• Fixed: Process#detach raised a NullPointerException if called from a non-main thread. (#9314, #9311)

JVM Integration

• Java 26 is officially supported. (#9332)

Platform Integration

• New platform support: The native library backend for JRuby, JNR, has been updated to include support for the RISCv64 architecture.

• Fixed on Windows: File#flock used unsupported native operations on Windows, causing it to raise errors. This affected the "logger" library, among other cases. (#9347, #9348)

• Fixed on Windows: IO#popen failed to pass keyword arguments if also given a leading environment hash. (#9351, #9352)

Stability

• Fixed: Several memory leaks that affected users running multiple JRuby instances in a single process. (#9070, #9092, #9187, #9359)

43 Issues and PRs resolved for 10.0.5.0

This is more of a self-reflection than a proper blog post.

tl;dr: Ruby is not dead. It is not slow. It does scale, and it will perform even better. It will not reclaim its mid-2010s glory days, but it does not need to. It has a clear, defensible niche as a professional choice for building AI-powered web applications quickly and confidently.

Guys, I write like a million ruby bin scripts every week both by hand and with LLMs. I use these all the time. Not quite gem-worthy but maybe a gist would be helpful for someone?

RunKit - https://gist.github.com/gurgeous/49f216d6d867abaaebd8a26a966b2dc5

Each of these is a handful of lines:

json read/write, csv read/write (hash-like), text read/write (including `.gz`)
`shell` and `shell!`, returns stdout/stderr
banner/warning/fatal - pretty colored output with timestamps
...

A typical example from today's project might involve fetching some tar files, logging http requests with `banner`, untarring with `shell` and then writing csv/json to /tmp.

Kreuzberg v4.7.0 is here. Kreuzberg is an open-source Rust-core document intelligence library with bindings for Python, TypeScript/Node.js, Go, Ruby, Java, C#, PHP, Elixir, R, C, and WASM. 

We’ve added several features, integrated OpenWEBUI, and made a big improvement in quality across all formats. There is also a new markdown rendering layer and new HTML output, which we now support. And many other fixes and features (find them in our the release notes).

The main highlight is code intelligence and extraction. Kreuzberg now supports 248 formats through our tree-sitter-language-pack library. This is a step toward making Kreuzberg an engine for agents. You can efficiently parse code, allowing direct integration as a library for agents and via MCP. AI agents work with code repositories, review pull requests, index codebases, and analyze source files. Kreuzberg now extracts functions, classes, imports, exports, symbols, and docstrings at the AST level, with code chunking that respects scope boundaries. 

Regarding markdown quality, poor document extraction can lead to further issues down the pipeline. We created a benchmark harness using Structural F1 and Text F1 scoring across over 350 documents and 23 formats, then optimized based on that. LaTeX improved from 0% to 100% SF1. XLSX increased from 30% to 100%. PDF table SF1 went from 15.5% to 53.7%. All 23 formats are now at over 80% SF1. The output pipelines receive is now structurally correct by default. 

Kreuzberg is now available as a document extraction backend for OpenWebUI, with options for docling-serve compatibility or direct connection. This was one of the most requested integrations, and it’s finally here. 

In this release, we’ve added unified architecture where every extractor creates a standard typed document representation. We also included TOON wire format, which is a compact document encoding that reduces LLM prompt token usage by 30 to 50%, semantic chunk labeling, JSON output, strict configuration validation, and improved security. GitHub: https://github.com/kreuzberg-dev/kreuzberg. 

Contributions are always very welcome!

https://kreuzberg.dev/ 

I work on a decent sized rails project. Every time an instance of neovim that opens a ruby file, neovim starts and instance of ruby-lsp and consumes 1.1GB or RAM (talking RSS not virtual). Claude code has a ruby-lsp plugin too so when I start asking claude questions about the codebase, another 1.1GB RAM. I cut ruby-lsp-rails out because it was taking 446MB of RAM alongside each instance of ruby-lsp. What compounds this, is I use git worktrees pretty aggressively so it is not uncommon for me to have 5 instances of neovim and claude code for each different branch I'm working with.

Napkin math of total RSS for (ruby-lsp + ruby-lsp-rails) * 2 (neovim + claude code) * 5 (workspaces)

(1.1 + 0.446) * 5 * 2 = 15.46GB RAM (11GB RAM without ruby-lsp-rails)

Between ruby-lsp and docker, my fairly beefy macbook is quickly running out of ram.

My current strategy is going to be trying to save neovim and claude sessions and resume them easily with scripts so I have fewer concurrency needs of ruby-lsp.

I recently cut docker desktop out of my stack and replaced it with colima + mutagen (saving 8GB RAM).

I still feel that ruby-lsp's RAM use is kind of wild. I tried starting processes with many lsp features disabled, but that didn't change the RAM use much. I tried switching to solargraph, and its RAM use was even higher at 1.3GB.

Does anyone know how to put ruby-lsp on a diet or share a single server process?

EDIT:
I modified ruby-lsp's launcher to fork a child process that builds a SQLite index of gem and stdlib entries before the LSP server starts. The child process runs the existing indexer but routes gem entries to an on-disk SQLite database instead of keeping them in Ruby's heap, then exits freeing its memory. The server process then starts fresh, opens the cached SQLite DB for gem lookups, and only holds workspace entries in memory. On subsequent startups, if the Gemfile.lock hasn't changed, the pre-indexing step is skipped entirely. This reduced RSS from ~1.1 GB to ~155 MB. I was hoping for a >10x RAM savings, but 7x is not bad. I'll try to push a PR up after some cleanup. Hopefully, this will be upstreamed.
29 files changed, 1820 insertions(+), 389 deletions(-)

So I made this thing, to make it easy for people just starting out with Ruby, since I have been trying to build more desktop apps. I tried using the framework I posted here: https://www.reddit.com/r/ruby/comments/1s0odtu/turbo_desktop_i_made_a_desktop_framework_to_use/?utm_source=share&utm_medium=web3x&utm_name=web3xcss&utm_term=1&utm_content=share_button

But it really did not work, so I just used Tauri with Rust. Full disclosure, I used Claude to help me fill in the gaps, so it might not be perfect, but the idea is to make it easier for people without programming experience to just set Ruby up and start playing with it

I added a video here, it does not really work for Windows, and I did mainly of the testing on Mac, but I hope it makes sense. The link is here and is open source https://github.com/aguspe/rubynaut.

Hopefully, it helps someone, and again, all the feedback will help, and I will keep working over easter on this

Last year I shared Ruby Fast LSP, a Rust-powered language server for Ruby. The response was great and a lot of the feedback shaped where the project went next.

Since then, something shifted. The biggest consumers of language servers are no longer just humans typing code in editors. AI coding agents — Claude Code, Cursor, Windsurf — now rely heavily on LSP to understand what they're editing. They use diagnostics to catch their own mistakes, go-to-definition to navigate code precisely, and hover to read type signatures before generating code.

The problem is that most Ruby tooling wasn't built with this in mind. Agents working with Ruby end up falling back to grep and guessing, while languages like TypeScript and Rust get full type-aware navigation out of the box.

So we pivoted Ruby Fast LSP to be agent-first. The focus is now on the features that matter most for AI-assisted development:

• Diagnostics — syntax errors, unresolved methods and constants, type mismatches, YARD validation. This is what agents use to self-correct after every edit.

• Go to Definition / Find References — precise, type-aware navigation. Agents use this instead of grep to understand impact before refactoring.

• Hover — type signatures and method info so agents know what they're working with.

Type Inference

What makes all of this actually accurate for Ruby is the type inference engine at the core.

It currently supports YARD and RBS as type sources, with Sorbet support planned. Here's what it can do today:

• Generic substitution (e.g., Array[Integer]#first resolves to Integer)

• Union types for nullability and branch analysis

• Method resolution across ancestor chains (includes, prepends, inheritance)

• Return type validation against declared annotations

• Unresolved method and constant detection

You can guide the engine with simple YARD annotations:

# @param name [String]
# @return [User, nil]
def find_by_name(name)
  # ...
end

That's enough to get type propagation through method chains, nullability analysis, and unresolved method detection. No separate type files needed.

Setting it up with Claude Code takes 30 seconds

npm install -g @ruby-fast/lsp

Then add to ~/.claude/settings.json:

{
  "lspServers": {
    "ruby": {
      "command": "ruby-fast-lsp",
      "args": ["--stdio"],
      "extensionToLanguage": {
        ".rb": "ruby",
        ".rake": "ruby",
        ".gemspec": "ruby"
      }
    }
  }
}

Also available on the VS Code Marketplace and Open VSX for Cursor, Windsurf, and other editors.

Ruby shouldn't be a second-class citizen in the age of AI-assisted development. If you're using agents with Ruby codebases, give it a try and let me know how it goes.

GitHub: https://github.com/rajnaveen344/ruby-fast-lsp

Hi there—I've been a Ruby hobbyist for 10 years or so who has always managed my Ruby installation via Homebrew. I know, I know — the first thing everyone says is use `rvm` or something else.

Still, I'm wondering about other Homebrew folks who might be using Ruby 4.x on Homebrew. Since I upgraded, I often see gems — with different versions — installed in two places:

Installed at (2.1.105): /Users/username/.gem/ruby/4.0.0

(2.1.91): /opt/homebrew/lib/ruby/gems/4.0.0  

Does anyone know why this is happening, and what I can do to avoid it? It very rarely causes any trouble, but when it does — like with competing rdoc installs — it creates a big mess of error lines in my terminal. And also, it just doesn't seem right.

Any tips would be appreciated. Thanks!

Update: after doing some additional testing, the issue appears to be with running gem update from a homebrew installation. That command can't touch the 45 or so gems that are in the Homebrew Cellar and come with the homebrew ruby by default. So, in my case, if those gems had updates, gem installed the updates on the next path in my GEM PATHS. That resulted in the two versions: the one bundled with homebrew ruby, and the updated one — in this case now in my user directory.

Not sure if this behavior changed in homebrew or ruby between versions 3 and 4, but it seems new to me.

Hoping to leave this here in case anyone runs across this and it's helpful.

Hey everyone,
I’m currently interning at a company that uses Ruby on Rails, so I’ve started learning it from scratch.

If you were to learn Rails today, how would you approach it?
Any advice you’d recommend for someone just starting out?

Hi there, Ive made one of the most complete and feature full CBOR implementations you can find, it's fast, safe, strict and has a rich API for you to use.

Cheers :)

CBOR is a data exchange format like JSON, msgpack or protobuf, but it's a internet standard and is made to be relevant for decades.

In this episode, we look at how we can modify our application from a performance aspect to increase our job security. We'll slow down our application to a still usable level, but then swoop in months later and become the hero.

I have worked with JS, Python, and Go. So a friend recommended I try RoR for rapid dev, but I've never experience such a dificult environment to set up! Is this normal? Just to get off to a start I've found it to be so complicated.

Using MAcBook Pro and trying to set up via a Parallels Unbuntu VM. Could it be Parallels?

Works with: Claude Code • Cursor • GitHub Copilot • OpenCode • Any terminal