Parklife is a Ruby library and CLI tool that converts Rack-based web applications (like Rails or Sinatra) into static HTML sites suitable for deployment on static hosting platforms (Netlify, Vercel, GitHub Pages, S3, etc.). It works by crawling the application's routes starting from defined entry points, making HTTP requests to each endpoint via Rack::Test, and saving the responses as appropriate files in a build directory. The library intelligently handles different HTTP response types through a responder pattern (200=OK, 304=NotModified, 404=NotFound, etc.), supports automatic link discovery and crawling from HTML responses, and provides flexible configuration for output formatting, caching via ETags, and 404 handling. Key features include route crawling with depth control, intelligent file naming logic (HTML vs other content types), and multiple reporter formats (progress dots, detailed logs, or silent).
Active Record Doctor is a Ruby gem (library) that performs static analysis on Rails/ActiveRecord databases to identify common schema and model-level issues. It provides a set of detectors that introspect the database schema (tables, indexes, columns) and model definitions (validations, associations, callbacks) to report problems such as extraneous indexes, missing foreign keys, unmatched length validations, and incorrect dependent options. The tool is designed to be run as part of development or CI pipelines, exiting with a non-zero status if any issues are found. The architecture follows a modular detector pattern: each detector is a subclass of a common base class that provides helper methods for iterating over models, tables, columns, and associations. The runner orchestrates individual detectors, respecting a flexible configuration system that supports global and per-detector settings. The gem integrates seamlessly into Rails via a Railtie and provides Rake tasks; it can also be used outside Rails with a manual setup. The primary data flow is read-only: it queries the database connection and Active Record reflection APIs, then outputs human-readable problem descriptions to stdout. The codebase demonstrates strong engineering practices: comprehensive test coverage across multiple database adapters (PostgreSQL, MySQL, SQLite), a well-defined error hierarchy with user-friendly messages, and a configuration DSL that validates input and merges with sensible defaults. The gem is actively maintained, supports recent Rails versions (7.0–8.0), and has a dedicated community (1900+ stars, 31 open issues, 68 forks).
Dawarich is a production Ruby on Rails 8 monolith for personal location history tracking, positioning itself as a self-hostable Google Timeline replacement. It ingests timestamped geospatial points from a broad range of trackers (OwnTracks, Overland, Traccar) and file formats (GPX, GeoJSON, KML/KMZ, TCX, FIT, CSV, Google Takeout), then drives them through heavy background processing: reverse geocoding, anomaly filtering, visit detection, track generation, transportation-mode classification, trip building, and monthly/yearly statistics with digest emails. The web frontend is a MapLibre GL JavaScript application using vector-tile rendering, WebSocket real-time updates, and novel in-browser encoding studios for route videos (WebCodecs MP4) and printable posters (hand-rolled PNG encoder). The system also integrates photo libraries (Immich, PhotoPrism), flight logs (AirTrail), TeslaMate, and TREK trip planning, plus family location sharing, achievements, and an MCP API endpoint. Architecturally it is a conventional but well-executed Rails service-object monolith: controllers are thin, domain logic lives in app/services (command pattern with call methods), heavy processing is delegated to a large Sidekiq job surface with named queues, and cross-process coordination uses Redis-based debouncers, per-user advisory locks, and tile epochs for cache invalidation. PostGIS powers spatial queries (ST_DWithin, lonlat geography, H3 hexagons, vector tiles). The codebase ships dual-mode: self-hosted Docker deployments and a cloud SaaS with subscription/entitlement gating, with many env-conditional branches. Test coverage is extensive (RSpec with regression specs for timezone/race/geospatial edge cases, Playwright e2e, locale-parity and schedule-consistency specs), CI includes RuboCop, Trivy, and Dependabot. The strongest engineering is in the data-ingestion and processing layer: streaming SAX-style JSON parsers for huge Google Takeout files, batched upsert with deduplication and Null Island filtering, deterministic nearest-centroid transportation-mode classification with explicit explainability, and Redis coordination patterns for geocoding claims and per-user job locks. Weaknesses include a sprawling surface area (35+ service subdomains in one repo), significant schema churn via migration-enqueued backfill jobs, and dual self-hosted/cloud branches that add cognitive load. Overall this is a well-maintained, feature-complete application with genuinely reusable geospatial and streaming-data patterns.
Lobsters is a production-grade Ruby on Rails application powering the social news aggregation and discussion site lobste.rs. It provides a full-featured platform for submitting, voting, commenting, and moderating links, with a focus on computing and technology topics. The architecture follows standard Rails MVC patterns with a rich set of controllers, models, views, mailers, and background jobs, using SQLite in production with SolidQueue for job processing and SolidCache for caching. The codebase emphasizes self-hosting, minimal external dependencies, and optional JavaScript, with a strong moderation system featuring hats, flags, bans, and a detailed moderation log. Key features include story submission with duplicate detection, threaded comments with Reddit-style confidence sorting, tagging and filtering, user invitations, private messaging, mod mail, full-text search, RSS feeds, and Fediverse integration via Mastodon. Authentication supports bcrypt, TOTP two-factor, and OAuth (GitHub, Mastodon). The application includes extensive test coverage with RSpec, factory_bot, and VCR for external HTTP interactions, and employs custom monitoring and security measures such as IP spoofing protection, rate limiting (Rack::Attack), and SSRF protection in its HTTP client. While primarily a standard Rails application, it contains several well-crafted, reusable components such as a custom HTTP client with SSRF protection, a Markdown renderer with username linking, and reusable concerns for token generation and username validation. The codebase is actively maintained with regular commits, though it acknowledges some 'dusty corners' and technical debt, such as inline partial duplication and a few brittle deployment-specific configurations. Overall, it is a solid, well-structured application that demonstrates good Rails engineering practices.
opal-rails is a Rails engine that integrates the Opal Ruby-to-JavaScript compiler into the Rails asset pipeline. It provides a build-based workflow where Opal entrypoints (Ruby files) are compiled into JavaScript assets via Rake tasks (`opal:build`, `opal:watch`, `opal:clobber`), replacing the older Sprockets request-time compilation. The gem includes generators for initial setup and asset scaffolding, a template handler for `.js.opal` views with optional controller assigns, and Haml/Slim filters for inline Opal code. It hooks into Rails' `assets:precompile` and test preparation tasks to ensure Opal assets are built automatically. The architecture is centered around a `BuilderRunner` that wraps `Opal::Builder`, an `OutputsManifest` that tracks built files, and a `WatchRunner` that uses the `listen` gem for incremental rebuilds during development. The codebase is well-structured with clear separation of concerns, dependency injection, and comprehensive test coverage, making it a solid example of a Rails engine that extends the asset pipeline.
Ahoy is a Rails engine that provides first-party analytics for Ruby on Rails applications. It tracks visits and events, storing data in the application's database by default while supporting custom data stores. The architecture follows Rails engine patterns with controllers, models, and concerns. Key features include automatic visit tracking, event tracking, geocoding via background jobs, IP masking for GDPR compliance, and associating visits with application models. The system provides both server-side Ruby tracking and client-side JavaScript/AMP/native app tracking through a configurable API.
PropsTemplate is a Ruby gem that provides a high-performance DSL for building JSON responses in Rails applications. It bypasses the typical hash-building-then-serializing approach used by libraries like JBuilder by using Oj's StringWriter directly, resulting in significantly better performance. The library supports advanced features including Russian-doll caching, layouts, partial rendering, deferment (lazy loading), fragment tracking for SuperglueJS integration, and template digging/searching capabilities. The architecture is well-structured with clear separation between core JSON building logic, extension modules (cache, deferment, fragments, partials), and Rails integration components.
Kaminari is a pagination library for Ruby on Rails and other web frameworks. It provides scope-based pagination for ActiveRecord models and generic arrays, with view helpers to render pagination controls. The architecture consists of three main components: kaminari-core (pagination logic), kaminari-activerecord (ActiveRecord adapter), and kaminari-actionview (view helpers). Key features include customizable pagination windows, optional count queries for performance, and support for multiple ORMs and template engines. The implementation demonstrates strong craftsmanship in its windowing algorithms, parameter handling, and the innovative 'without_count' optimization that avoids expensive COUNT queries by fetching one extra record.
Ciao is a self-contained, zero-external-dependency HTTP(S) endpoint monitoring application built with Ruby on Rails 8. It schedules periodic health checks with cron syntax using the in-process rufus-scheduler, stores state in a local SQLite database, and notifies users of status changes via email or configurable webhooks (e.g., Slack, Rocket.Chat). The application also monitors TLS certificate expiration for HTTPS endpoints and sends alerts when certificates are due to expire. It provides a web UI with a dashboard, a RESTful JSON API, optional Prometheus metrics, and HTTP Basic authentication. The codebase is a standard Rails monolith with a single process for web server, scheduler, and background work, making it easy to deploy (Docker, Helm chart, or direct Ruby). The architecture is simple but effective for small-to-medium monitoring needs.
This is the main application for The Odin Project, a free and open-source web development curriculum. It is a Rails 8.1 monolith that provides a learning management system (LMS) with user authentication, lesson tracking, project submissions, flagging/moderation, and an admin panel. The application imports lesson content from a separate GitHub repository, converts Markdown to structured HTML using custom Kramdown converters, and tracks user progress through materialized SQL views. It features a modern Hotwire frontend (Stimulus + Turbo), Tailwind CSS, and extensive use of ViewComponents. The codebase is well-tested with RSpec, including system and request specs. While primarily an application, it includes analytical reporting via materialized views and daily summary jobs, giving it a hybrid nature leaning heavily toward application.
Ruby2JS is a Ruby-to-JavaScript transpiler with a modular filter architecture. It converts Ruby source code into JavaScript by parsing Ruby AST (via Parser gem or Prism) and applying a pipeline of filters that transform Ruby idioms into JS equivalents. The project includes a self-hosting capability (transpiles itself to JS), a Rails-like micro-framework called 'juntos' for building full-stack JS apps, and build tool plugins for Vite, esbuild, Rollup, and Webpack. It supports multiple output targets (ESM, CJS, JSX, React, Lit, Stimulus, etc.) and framework-specific filters for Rails, Phlex, Vue, Svelte, Astro, and more. The architecture is well-structured with clear separation between parsing, filtering, conversion, and serialization. The codebase is actively maintained with extensive test coverage and a monorepo structure for npm packages.
This Rails 8.0 monolithic web application serves as a conference scheduling and attendance management platform, specifically built for the Rails World conference. It allows authenticated users to browse an agenda of sessions (talks) sorted by time and location, bookmark sessions to create a personal schedule, and receive proactive reminders via email and web push notifications. Administrators manage conferences, sessions, speakers, locations, and tags through the integrated Avo admin panel. The app also supports PWA installation, guest browsing of public sessions, and a profile system with social links and QR code sharing. Under the hood, the application leverages Hotwire (Turbo + Stimulus) for a responsive, single-page-like experience without a JavaScript framework. Background jobs are handled by SolidQueue with a separate SQLite database, including recurring tasks for session reminders and Litestream backup verification. Notifications are implemented using the Noticed gem with custom web push delivery. The authentication system uses bcrypt and includes password reset flows; authorization is managed via ActionPolicy. The codebase is thoroughly tested with RSpec including system tests using Cuprite, and includes a comprehensive CI pipeline with linting (RuboCop, ERB Lint, StandardJS), security scanning (Brakeman, bundler-audit), and code quality checks (RubyCritic, DatabaseConsistency). While not a generic SaaS, the architecture is clean and follows Rails conventions closely. Several components (form builder, query object, feature flag module, custom notification delivery) are well-isolated and demonstrate patterns that could be extracted into other Rails projects. The use of SQLite with Litestream replication and Kamal deployment reflects a modern, low-ops approach to hosting.
The thoughtbot dotfiles repository provides a comprehensive set of configuration files and scripts to set up a developer's environment, primarily targeting Zsh, Vim, Tmux, and Git. It uses the rcm tool to manage symlinking of dotfiles into the user's home directory, allowing for easy updates and local overrides. The repository includes shell aliases, functions, and key bindings for Zsh; Vim configuration with plugins for enhanced functionality (including fzf, vim-rails, and ALE linting); Tmux configuration for improved status bar and navigation; and Git configuration with useful aliases and hooks. Additionally, it provides a collection of helper scripts in the `bin/` directory for common tasks such as branch management, port clearing, and file replacement. The architecture is modular, with separate directories for Zsh, Vim, Git templates, and bin scripts. The Zsh configuration is split into configs, functions, and completions, which are loaded in a specific order. The Vim configuration uses vim-plug for plugin management and includes settings for syntax highlighting, linting, and navigation. The Tmux configuration improves color resolution, removes administrative debris from the status bar, sets the prefix to Ctrl+s, and softens the status bar color. The Git configuration adds aliases for creating, deleting, merging, and renaming branches, fetching and rebasing onto the default branch, and trusting project bin directories. It also includes hooks to regenerate ctags after certain Git operations. Key reusable components include the `git-up` script for rebasing onto the default branch and the `tat` script for tmux session management. These scripts are isolated, self-contained, and demonstrate practical solutions to common developer workflows. The configuration adapts to available tools (e.g., using ripgrep if present, falling back to the Silver Searcher) and incorporates modern practices such as using asdf for version management and setting up a safe bin path for trusted repositories.
This is a Redmine plugin that allows administrators to define custom Ruby scripts that execute on lifecycle events (before_save, after_save, before_destroy, after_destroy, etc.) for various Redmine objects such as Issue, User, Group, Project, Attachment, TimeEntry, Version, WikiContent, and more. It uses Rails monkey-patching (prepend) to inject callbacks into Redmine models and controllers, and executes user-defined scripts via `instance_eval` in the context of the observed object. The plugin provides a web UI for managing workflows, supports import/export via XML, and includes a custom mailer for sending emails from workflows. It is well-structured, has comprehensive tests, localization support, and CI integration. The codebase is mature and actively maintained, targeting Redmine 6.x and Rails 8.1.
Hyrax is a Ruby on Rails engine for building digital repository applications, part of the Samvera community. It provides core functionality for managing scholarly works, collections, file sets, and administrative sets with full lifecycle support: ingest, metadata management, access control (permissions, embargoes, leases), workflow (mediated deposit), analytics (GA4, Matomo), IIIF manifests, fixity checking, and derivatives generation. The architecture is a monolith with a modular actor middleware stack (chain of responsibility) for work creation/update/destroy, dry-transaction steps for resource operations, and a pub/sub event system for decoupled side effects. It supports dual persistence via ActiveFedora (Fedora) and Valkyrie (PostgreSQL, Fedora 6), with migration infrastructure (Wings, Freyja) and a Solr indexing layer. Key entry points include Rails controllers (Blacklight-based search, admin dashboard, API), the actor stack, and transaction steps. The codebase is heavily engineered with reusable patterns but carries significant technical debt from the ongoing migration to Valkyrie, deprecation warnings, and conditional code paths.
Octobox is a self-hosted, open-source web application for managing GitHub notifications. Built as a Ruby on Rails monolith (Rails 8.1, Ruby 3.x), it syncs notifications from the GitHub API into a PostgreSQL database, providing a rich UI for filtering, archiving, muting, starring, and searching notifications. Background jobs via Sidekiq handle syncing subjects, labels, comments, and performing actions like marking notifications as read on GitHub. Real-time updates are pushed via ActionCable. The application also exposes a REST API for programmatic access and supports GitHub App and OAuth authentication. It is designed for both hosted (octobox.io) and self-hosted deployments, with Docker, Heroku, and OpenShift support. The codebase is well-tested with Minitest and system tests, and follows standard Rails conventions with some custom patterns for search parsing and API client pagination.
This is a demo application showcasing ActiveAdmin functionality for Ruby on Rails. It provides an admin interface for managing AdminUser records with Devise authentication, featuring CRUD operations, a customizable dashboard, and proper error handling. The application follows standard Rails MVC architecture with ActiveAdmin as an engine/plugin, uses Importmap for JavaScript bundling, and CSS Bundling with TailwindCSS for styling. It includes comprehensive test coverage and is actively maintained with CI/CD pipelines.
FarmBot Web App is the cloud-based control panel for FarmBot, an open-source CNC farming robot. It provides a full-stack web application (Rails API + React/TypeScript SPA) for managing devices, creating automated sequences via a visual CeleryScript AST editor, scheduling farm events, monitoring telemetry and logs, managing plants/weeds/tools, and viewing real-time 2D/3D garden maps. The backend is a monolithic Rails app with PostgreSQL, RabbitMQ/MQTT for device communication, and DelayedJob for background processing. The frontend is a complex Redux SPA with extensive 3D visualization using Three.js. The system supports multiple hardware variants and includes firmware update management, camera calibration, and AI-assisted feedback. The codebase is actively developed with a large test suite, but exhibits some technical debt like legacy AST storage paths, future-dated migrations, and heavy mocking in tests.
Timeasure is a Ruby gem for transparent method-level runtime profiling in production environments. It uses `Module#prepend` and metaprogramming to intercept method calls on classes and modules that include the `Timeasure` module, measuring execution time via `Process.clock_gettime(Process::CLOCK_MONOTONIC)`. The gem provides class macros (`tracked_instance_methods`, `tracked_class_methods`, etc.) to declare which methods to profile, and a direct `Timeasure.measure` interface for manual instrumentation. Measurements are aggregated by method path (class and method name) and optionally segmented by custom values, stored in an in-memory `ReportedMethodsHandler`, and exported via `Timeasure::Profiling::Manager.export`. The architecture is a simple library with configurable procs for post-measurement handling and error rescue, allowing users to integrate with external services like New Relic or Keen.io. The codebase is small, well-tested, and cleanly structured, but has not been updated since 2018, leading to outdated dependencies and a Ruby version target of 2.1+.
devise_zxcvbn is a Ruby gem that integrates Dropbox's zxcvbn password strength estimation into Devise, a popular Rails authentication framework. It adds a `zxcvbnable` module that validates password strength during user registration or password changes, rejecting passwords below a configurable minimum score (default 4). The gem uses the `zxcvbn-rb` library to compute password strength, and optionally incorporates the user's email and custom weak words to improve accuracy. The codebase is small, well-structured, and includes RSpec tests. However, it has not seen significant updates since 2021, relies on an older version of the zxcvbn gem, and only tests against Ruby 2.6–3.0, indicating some technical drift. It remains a functional and reliable solution for Rails applications needing server-side password strength validation.