While I was using the Mac, I had the option to use Dash from Kapeli (great app btw and the inspiration for Dravos), but it lacked versions for Linux (which I also use) and Windows (which my wife uses). I waited for years to see if someone would do a viable alternative for my workflow, that never became true, so over the past 9 months give or take, I’ve been working my nights and weekends into building Dravos, a fast, offline-first documentation search tool for developers.

As an indie maker who's shipped several smaller projects before, this one pushed me the hardest: learning new stacks and obsessing over that instant search feel even without the internet. It's finally ready for beta. If you're a developer who lives in docs (Dash, DevDocs, etc.), I'd love your honest feedback to make it truly useful before the full launch.

For those who might find interesting I used Tauri + Typescript. And it works on mac, linux and windows. I tested a lot by myself/wife, but now I need help. Im looking for people to try it on your workflow, and tell me what works and what doesn't, if this feel usefull to you please help me test it ❤️

So far we support, Rust, Elixir, Ruby, Python and Go and all its packages. We also support custom documentation generated with Doxygen, Sphinx, JSDoc. There is a limit of 50 spots for this first beta wave.

Heres the site: https://dravos.app, you can check the roadmap here: https://dravos.app/roadmap changelog here: https://dravos.app/changelog

PS: I have a discord setup too for responding any questions/suggestion/bug you might find. its in the site footer.

Example of searching for string in ruby

Example of doc for Python

My friend Claude and I wrote a DSL to define surveys and forms.  I created it as a side project based on the pain of working with Qualtrics, Dimensions, etc survey formats. Most existing formats are either proprietary/xml-based or non-existent (interactive form-builder style).  I thought “there must be a better way to define and communicate the structure of a survey”.  Ruby’s flexibility and blocks made it a natural choice for me to build upon. After a lot of prompts and tinkering I have a small, readable language that defines a survey with skips, based-on, etc.

Some benefits:
- Simple.  The logic and flow are easy for most anyone to read and understand.  
- Small.  The language definition can be described in a small markdown file and shared with an AI.
- Portable.  It’s just a text file.
- Git diffable.  It’s just a text file.
- Flexible.  Can render to different formats like html survey, html form, XForm for kobotoolbox, etc.

I have an information site and a playground if this seems interesting or you would like to learn more.

I have not open-sourced it (yet?) because I am still a single developer with big dreams of leveraging it into a possible small SAAS. I typically build things and then let my ideas die on the vine, so if you have any thoughts or inspiration, my DMs are open 😄

Cheers! and humble thanks to the Ruby community for providing such an amazing language that has fueled a large part of my career.

Written in Rust. CommonMark+GFM conformant. Features include: strong security by default and host/protocol whitelists for links and images, syntax highlighting, frontmatter, ToC, plain text export, structured extraction of headings/images/links/code, statistics with char/word count and language detection, emoji shortcodes.

AI-friendly features include: two chunking primitives: heading-based with breadcrumbs and per-chunk char/word counts, and sliding-window with overlap for size-bounded chunks; block-aware or word-aware truncation for context-window budgeting; Markdown-to-Markdown pipeline.

Explore Shopify's rubydex static analysis engine, docscribe v1.3.1 with RBS inference consistency, sentinel-rb's Rust rewrite, claude-ruby-plugins, and the R gem.

Link in the comments.

Stay typed! ✨

Hello, everyone I launched (with Claude help) this gem that makes use of the `ActiveJob::Continuation` API

This gem adds persistent progress tracking of the running task (example: a file upload), a durable notification inbox aimed at the end user and a Hotwire/turbo-rails UI scaffold. Turning the resumable `ActiveJob::Continuation` steps into a state machine that handles notifications without the need for manual broadcasting configuration.

It's still in alpha, feel free to test, contribute and criticize

https://rubygems.org/gems/notificare

Hey everyone,

Three months ago I posted about FindBug, a self-hosted error tracking gem for Rails. The feedback was way more than I expected - and a few specific asks came up over and over. v0.5 is the release that ships them.

TL;DR: No more jsonb - only. Works on PostgreSQL, MySQL, and SQLite now, with the adapter detected automatically. 79 RSpec examples covering every adapter path. Yes, AI helped build parts of this - more on that below.

What v0.5 ships

1. Database-agnostic - your #1 ask

Until now FindBug was effectively PostgreSQL-only. The migrations used jsonb, the dashboard's time-bucket queries used `date_trunc()`. If you were on MySQL or SQLite, things broke in interesting and embarrassing ways.

v0.5 detects your ActiveRecord::Base.connection.adapter_name at migration and query time, and picks the right column types and SQL functions per adapter.

Application code is identical across adapters - the model's JSON accessors normalise reads to native `Hash` / `Array` regardless of underlying storage. And the helper that drives this is part of the public API, in case you want to write your own migrations against the same strategy:

Existing PG users - this is fully backwards compatible. Your schema doesn't change, your code doesn't change, you just `bundle update findbug` and carry on.

2. Tests, for real this time

When I shipped v0.4, the test suite was - let's call it "aspirational." For v0.5 I wrote 79 RSpec examples covering:

- Adapter detection across PostgreSQL / MySQL / SQLite (using stubbed connection names so we test every branch)

- JSON column round-trips on real SQLite text columns - round-trip Hash → text → Hash, malformed JSON, pre-serialised strings, nil

- JSON accessor behaviour on stubbed `jsonb` / `json` columns - verify the setter passes through to AR's native type system without double-encoding

- Model behaviour - validations, fingerprint upsert, percentile aggregation, time-series queries

- Edge cases I'd been quietly hoping nobody would hit

The suite runs against in-memory SQLite, so contributors can send PRs without standing up a PG cluster.

On AI - being straight about it

I want to put this out there because I think the community deserves honesty: I used AI (Claude, mostly) extensively while building FindBug. Code review, hunting edge cases, scaffolding tests, refactoring loops for clarity, generating doc tables, the boring CSS.

What I did not outsource:

- The "never block the request" rule

- Why a dedicated Redis connection pool, separate from the app's

- Why fingerprint-based aggregation instead of storing every event

- Why a background thread by default and ActiveJob as an opt-in

- The decision to make alert channels DB-driven so they're configurable from the dashboard without redeploys

- Which features ship in which release

AI sped up the typing; the engineering judgment was mine. I'd rather say that out loud than pretend a solo dev shipped 7,000 lines of code at side-project velocity through pure caffeine.

What's coming in v0.6

Driven entirely by comments on the last thread:

- Frontend JS error tracking for Rails apps that render views - a findbug_js_tag helper that injects a tiny snippet, an ingest endpoint inside the engine, frontend errors flowing through the same Redis → DB pipeline with `source: "javascript"`. Same-origin only, so no source-map gymnastics in v0.6.

- Valkey support - Valkey is a drop-in Redis replacement after Redis Inc.'s licensing shenanigans. Should mostly Just Work, but I want to test and document it explicitly so people don't have to guess.

- Solid Queue as an alternative to Redis - for apps already on Solid Queue who'd rather not run a separate Redis just for FindBug's buffer.

- No-Redis (and no-Valkey) mode - for tiny apps that don't want to introduce a key-value store at all. Direct DB writes, with a big "you'll pay the latency cost" warning in the docs. Opt-in.

- Separate database for FindBug events - point the gem at its own DB via connects_to, so error data lives in a dedicated operational database instead of bloating your application DB. Useful for multi-tenant apps and for keeping retention windows independent of your main DB's backup strategy.

If one of these matters more to you than the others, comment and I'll prioritise.

Links

- Site & live demo: https://findbug.dev

- Docs: https://findbug.dev/docs

- RubyGems: https://rubygems.org/gems/findbug

- GitHub: https://github.com/ITSSOUMIT/findbug ← ⭐ if it's useful to you

If you tried v0.4 and bounced because of the PG-only limitation, this is the release for you. And if you've got opinions on the v0.6 roadmap - particularly the no-Redis path - drop them in the comments. Every priority above came from feedback on the last thread; I'd like to keep it that way.

One small ask: if FindBug solves a problem for you (or even just looks like it might), a ⭐ on the repo goes a long way. It's the main signal other Rails devs use to decide whether a side-project gem is worth trying, and right now it's the difference between FindBug being a "weird thing I built" and "thing people actually use." No pressure if it's not your thing - just thanks for reading this far either way.

- Soumit

Link to the launch post of FindBug -
https://www.reddit.com/r/rails/comments/1rea800/i_built_findbug_a_selfhosted_opensource_error/?utm_source=share&utm_medium=web3x&utm_name=web3xcss&utm_term=1&utm_content=share_button

I have always wanted to have a blog, and so I finally got started! I hope you enjoy reading my post -- I had fun writing it. I am aware that the usability / readability of my site is... questionable at the moment. And, no SSL. But, the entire site is generated by a single Rakefile using Markaby, with everything smashed together!

I'm getting errors about 'nm.' I'm using Homebrew and have updated and upgraded. Any suggestions?

Building libruby.a

error: nm: invalid argument --

Usage: nm [-agnopruUmxjlfAPL[s segname sectname] [-] [-t format] [[-arch <arch_flag>] ...] [file ...]

partial linking /var/folders/v8/gxq0lntj0nzd0xlwy46nlr1c0000gn/T/ruby-build.20260516211244.9333.xsqcwY/ruby-4.0.3/target/release/libruby.a into /var/folders/v8/gxq0lntj0nzd0xlwy46nlr1c0000gn/T/ruby-build.20260516211244.9333.xsqcwY/ruby-4.0.3/target/release/libruby.o

linking miniruby

Undefined symbols for architecture arm64:

"_rb_yjit_before_ractor_spawn", referenced from:

_ractor_create in ractor.o

"_rb_yjit_bop_redefined", referenced from:

_rb_vm_check_redefinition_opt_method.cold.1 in vm.o

EDIT: The error was that the Homebrew package 'anaconda' installs its own 'nm' and prepends its bin directory to your path. Fixing this solves the issue. Ruby needs the 'nm' from the 'binutils' package.

Is anyone else (we're UK based) having problems connecting to rubygems.org?

We're getting DNS timeouts. Doing a dig looks like dns simple is down (we've tried from our office and AWS servers to rule out an issue here).

It's been down for us since yesterday late afternoon.

1. Eloquent Ruby

Author: Russ Olsen

This book starts by answering many simple tactical questions on Ruby and then goes on to address bigger questions related to building methods and classes. You will find several tips and tricks, such as when to use tiny methods and operator overloading, and when you should avoid them. It also emphasizes the “Ruby way” of thinking and problem solving to write “eloquent” and beautiful Ruby code.

2. The Well-Grounded Rubyist

Author: David A. Black

This book is divided into three major parts: Ruby foundations, Built-in Classes and Modules, and Ruby Dynamics. It begins with how to write your first Ruby program and goes on to cover more advanced topics such as threading, reflection, and callable objects. It also covers all the new Ruby features, such as lazy enumerators, keyword arguments, and Module#prepend.

Which other books would you add to this list?