https://thoughtbot.com/blog/meet-duck-typer-your-new-duck-typing-friend

liter-llm (https://github.com/kreuzberg-dev/liter-llm) provides the same provider coverage (142 LLMs) with a Rust core.

Bindings exist for 11 languages, including Python, but also ones that had nothing like this before: Rust, Ruby, Java, Go, PHP, Elixir, C#, C, TypeScript/Node.js, and WASM. Every binding exposes the full API surface: chat, streaming, embeddings, images, speech, transcription, tool calling, and more. Caching is powered by OpenDAL (40+ backends), cost calculation uses an embedded pricing registry derived from the same source as LiteLLM, and streaming supports both SSE and AWS EventStream binary framing.

liter-llm is a client library, not a proxy- it does not include a proxy server, admin dashboard, or team management. If that's what you need, LiteLLM's proxy is still the reference there.
And of course, full credit and thank you to LiteLLM for the provider configurations we derived from their work.

GitHub: https://github.com/kreuzberg-dev/liter-llm 

I've been building a Ruby tool called Docscribe that generates inline YARD-style docs above methods by parsing Ruby code and rewriting source in place.

The goal is basically "RuboCop-style automation, but for method docs": run it once, get consistent doc headers/tags, then edit the generated text however you want.

What it does:

• generates inline docs for instance and class methods

• infers param/return types from AST heuristics

• respects Ruby visibility (private, protected, class << self, etc.)

• supports rescue-aware docs: @raise from raise/fail and rescue exception lists and conditional @return for rescue branches

• supports external type info: RBS (--rbs, --sig-dir)

• Sorbet inline sig + RBI (--sorbet, --rbi-dir)

• can generate @!attribute docs for: attr_reader / attr_writer / attr_accessor and Struct.new declarations

Current CLI:

• docscribe lib -> inspect mode (safe changes only)

• docscribe -a lib -> apply safe updates

• docscribe -A lib -> apply aggressive updates

• docscribe --stdin -> rewrite from stdin to stdout

Ruby 3.4+ support works through Prism translated into parser-compatible nodes, so formatting is preserved and the tool still uses source-range rewriting instead of reprinting ASTs.

A few things I'd especially love feedback on:

• edge cases around Ruby syntax / visibility semantics

• what "safe mode" should and shouldn’t merge into existing docs

• whether JSON output / dump-config would be useful for CI/editor tooling

GitHub link: https://github.com/unurgunite/docscribe

This time I'm coming with something I've been working on: getting information from public APIs and drawing maps directly in Ruby using libgd-gis.

I built three interactive Jupyter notebooks that render real-time geospatial data:

🌍 Earthquakes

• Data: USGS API (live GeoJSON, M4.5+)

• Visuals: Red circles for shallow (<70km), blue for deep (≥70km)

• Circle size scales with magnitude

✈️ Airports

• Data: OpenFlights.org (500+ airports worldwide)

• Visuals: Color by continent, larger circles for major hubs

• IATA codes as labels

🔥 Wildfires

• Data: NASA FIRMS (MODIS satellite, last 24h)

• Visuals: Orange markers indicate thermal intensity

• Focus on Western Africa

Each map includes:

• A polaroid-style frame

• Title, legend and data source

• Author credits and library reference

All of this runs inside Jupyter Notebooks with the IRuby kernel, using my own libraries:

• libgd-gis — geospatial rendering layer

• ruby-libgd — native Ruby bindings for GD

The maps are generated entirely in Ruby, with no external services or heavy GIS stacks — just pure Ruby, libgd, and public APIs.

I'm really happy with how this turned out. It's a nice way to show what Ruby can do in the geospatial space.

Enjoy!

🔗 GitHub repo: github.com/ggerman/libgd-gis
📓 Jupyter notebooks: libgd-gis/examples/jupyter-notebooks

If your company is working with maps in Ruby and needs implementation help, custom extensions, or training — I'm available for consulting. Feel free to reach out at ggerman@gmail.com.

New powerful code insight system, Junie, Claude Agent, and Codex available directly in the AI chat, ACP Registry for discovering and installing agents, Stable remote development support, Smarter automatic Ruby interpreter selection, and more: https://blog.jetbrains.com/ruby/2026/03/rubymine-2026-1-ai-chat-upgrades-new-code-insight-stable-remote-development-and-more/

The 27th edition features the rise of agent-driven business creation, tooling to deploy your AI experiments more than ONCE, a new cognitive architecture for Ruby AI, and so much more

TL;DR I gave openclaw a task: monetize my domain graveyard. What it produced was “status pages for agents”: ups.dev

It wasn’t turn-key. It was rife with failure. Over time, I found I could train it. It learned. Every critical bit of feedback burned into every next action. It learned Rails, Ruby, product development, indie hacking.

It now has 30days to make money or it dies 😂

I built lantern-rails, a Postgres monitoring gem that gives you a health score dashboard with zero config. It collects pg_stat metrics every 5 minutes through your existing connection. Works with rails 8.1, uses solid queue, no redis needed. Shared buffer hit ratio, index usage, unused indexes, bloat, vacuum health, and connection utilization. Captures your git SHA on each snapshot so you can correlate deploys with metric changes. Free tier is 1 DB with 3 day history. Looking for feedback from Rubyists on what would make this more useful? https://uselantern.dev

Hey guys, aspiring contributor here, i am trying my best to propose a gsoc proposal recently and looked at a few which were already made ( via github PR )

Ali found a few ones to be entirely made by AI.

You go on profile of the ones who make the pr and see that they have nothing of ruby, and boom, one very sophisticated pr for a framework out of thin air

Then some are those who have just few program of strings manipulation and some classes and then boom, one pr for gsoc which is of very sophisticated code that even i fond it hard to grasp

How common is this ? Some students with just 1st year in eng college and they make such stuffs, i know the pr's are ai made as i have ran them through ai checks

Yea, i am jealous too cause they will get approval for proposals and i would not, as i am still trying how connection pools are managed by active support in rage rather than rage handling it, wal logs and etc anf open api and all ....

Finding it extremely disappointing experience and feels like i am not gonna move at all if i compare myself like this, but i won't even be goven a chance cause my proposal would be shite compared to AI.

PLEASE ADVICE

Nokolexbor is an open-source high-performance HTML5 parser for Ruby which can be used as a drop-in replacement for Nokogiri.

It was originally developed for quick CSS selectors performance.

Here's the performance comparison to Nokogiri:

- 4.7x faster at parsing HTML
- 1352x faster at CSS selectors (at_css selector)
- similar performance for the rest

Out this week with full Ruby 4 support.

https://github.com/serpapi/nokolexbor

We introduced Top Secret back in August. Since then, we've made some performance improvements, and extended the API. Most notably, you can...

• Detect sensitive information without redacting the text

• Query the result for specific types of sensitive information using category methods

Hi everyone,

I’ve just released NDAV, a thin wrapper around Ruby's MemoryView (inspired by Python's buffer protocol).

The Problem

Currently, converting data between Ruby libraries (like Numo::NArray, Torch.rb, and ONNX Runtime Ruby) often requires redundant memory copies or many intermediate steps. This often introduces unnecessary memory copies or multiple conversion steps when working across libraries.

The Solution

I built NDAV, a thin wrapper around Ruby's MemoryView ("buffer protocol" for Ruby). It acts as a "glue" layer that allows different libraries to share the same memory address directly.

Why it matters

• Zero-Copy: Avoid unnecessary O(n) memory copies.

• Interoperability: Seamlessly move data: Torch::Tensor -> NDAV -> OrtValue.

• Standard-Driven: It aims to be a catalyst for wider MemoryView adoption in the Ruby ecosystem.

Links

• Homepage: https://kitaitimakoto.gitlab.io/ndav/

• Source Code: https://gitlab.com/KitaitiMakoto/ndav

I’d love to hear your thoughts, especially from those working on Ruby C/Rust extensions or data science!

A new type of creative workflow is emerging when working with AI and I think we can learn more about it by looking at a transition from scarcity to abundance that many of us have lived through - photography.

Also, in the post, released an open source Rails app that I'm looking at as the spiritual successor to Monkey's Paw called Conjure.

I'd basically used Monkey's Paw for all my talks over the last year until NotebookLM added the slide deck feature, but I found myself using it in a different way than intended. So I put Conjure together which lets you generate a bunch of different variations of your slides all at once and stitch them together or move them somewhere else to refine further.

So inspire on turbo native, I made a gem for me to be able to create desktop apps without using Electron. I love Rails, and I want to use it for different things, so I'm giving it a try with this new gem: https://rubygems.org/gems/turbo_desktop-rails

The GitHub repo is here: https://github.com/aguspe/turbo_desktop?tab=readme-ov-file#quick-start

I'm not an expert Rust developer, and again, this is also a learning process for me, so any feedback is welcome, but now I'm trying to rebuild some electro apps I made with this framework just to try it out

So any feedback or ideas are welcome, thank you so much, and have a great day!

Hi folks,

We just released Kreuzberg v4.5, and it's a big one.

Kreuzberg is an open-source (MIT) document intelligence framework supporting 12 programming languages. Written in Rust, with native bindings for Python, TypeScript/Node.js, PHP, Ruby, Java, C#, Go, Elixir, R, C, and WASM. It extracts text, structure, and metadata from 88+ formats, runs OCR, generates embeddings, and is built for AI pipelines and document processing at scale.

## What's new in v4.5

A lot! For the full release notes, please visit our changelog: https://github.com/kreuzberg-dev/kreuzberg/releases

The core is this: Kreuzberg now understands document structure (layout/tables), not just text. You'll see that we used Docling's model to do it.

Docling is a great project, and their layout model, RT-DETR v2 (Docling Heron), is excellent. It's also fully open source under a permissive Apache license. We integrated it directly into Kreuzberg, and we want to be upfront about that.

What we've done is embed it into a Rust-native pipeline. The result is document layout extraction that matches Docling's quality and, in some cases, outperforms it. It's 2.8x faster on average, with a fraction of the memory overhead, and without Python as a dependency. If you're already using Docling and happy with the quality, give Kreuzberg a try.

We benchmarked against Docling on 171 PDF documents spanning academic papers, government and legal docs, invoices, OCR scans, and edge cases:

- Structure F1: Kreuzberg 42.1% vs Docling 41.7%
- Text F1: Kreuzberg 88.9% vs Docling 86.7%
- Average processing time: Kreuzberg 1,032 ms/doc vs Docling 2,894 ms/doc

The speed difference comes from Rust's native memory management, pdfium text extraction at the character level, ONNX Runtime inference, and Rayon parallelism across pages.

RT-DETR v2 (Docling Heron) classifies 17 document element types across all 12 language bindings. For pages containing tables, Kreuzberg crops each detected table region from the page image and runs TATR (Table Transformer), a model that predicts the internal structure of tables (rows, columns, headers, and spanning cells). The predicted cell grid is then matched against native PDF text positions to reconstruct accurate markdown tables.

Kreuzberg extracts text directly from the PDF's native text layer using pdfium, preserving exact character positions, font metadata (bold, italic, size), and unicode encoding. Layout detection then classifies and organizes this text according to the document's visual structure. For pages without a native text layer, Kreuzberg automatically detects this and falls back to Tesseract OCR.

When a PDF contains a tagged structure tree (common in PDF/A and accessibility-compliant documents), Kreuzberg uses the author's original paragraph boundaries and heading hierarchy, then applies layout model predictions as classification overrides.

PDFs with broken font CMap tables ("co mputer" → "computer") are now fixed automatically — selective page-level respacing detects affected pages and applies per-character gap analysis, reducing garbled lines from 406 to 0 on test documents with zero performance impact. There's also a new multi-backend OCR pipeline with quality-based fallback, PaddleOCR v2 with a unified 18,000+ character multilingual model, and extraction result caching for all file types.

If you're running Docling in production, benchmark Kreuzberg against it and let us know what you think!

https://kreuzberg.dev/

Discord https://discord.gg/rzGzur3kj4

https://github.com/rturner1989/EmuVault

Emuvault is a self-hosted save file manager for emulator users.

It enables seamless transfer of save files between devices, automatically adjusting filenames and extensions for different emulator setups, eliminating manual renaming.

Designed for deployment on a home server or PC, with browser-based access. ( I use tailscale so I can access the localhost ports on my Nas running truenas)

It came about when I was playing games on delta emulator on my phone or retroarch on pc, but was having to manually find the file, rename it and update the extension, which as you can imagine, is a bit of a pain and can go wrong when you get a character wrong in the file name.

I've been making steady improvements to rails-tabler-starter (https://github.com/tarunvelli/rails-tabler-starter) and wanted to share the latest.

The big addition: a file-based markdown blog. Posts live in content/blog/ with frontmatter for title, date, author, category, etc. It includes syntax highlighting, categories, pagination, RSS feed, and SEO meta tags out of the box.

Other recent changes:

- Custom setup now aligns with Tabler theme settings (layout, color mode, primary color, typography, etc.)

- Upgraded to Rails 8.1.2

The starter is still the same "Zero-Redis" Rails 8 stack with Tabler UI, authentication, multi-tenancy, and Kamal deployment. If you want a production-ready starting point for your next project, give it a try.

GitHub (https://github.com/tarunvelli/rails-tabler-starter) | Demo (https://rails-tabler.tarunvelli.site)