The Rhino framework provides a powerful Rails + React foundation for building modern web applications. Whether you're starting a new project from a Product Requirements Document (PRD) or exploring the framework's capabilities, this guide will walk you through the essential steps to get your Rhino application up and running.
Rhino's UI is intentionally "open"—you can keep the defaults, or you can surgically replace any piece of the interface. The mechanism that makes this possible is overrides. In this three-part series, we'll walk through why and how to override, what you can (and can't) swap, the safest workflow for copying base components, and the sharp edges to avoid.
This first part covers the foundations: understanding what overrides are, when to use them versus composing with existing components, and establishing a safe, repeatable workflow.
In Part 1, we covered the foundations of Rhino's override system—what overrides are, when to use them, and the basic workflow. Now we'll dive into the tricky parts: overriding behavior (not just markup), leveraging paths for fine-grained control, and real-world patterns that work in production.
In Part 1 and Part 2, we covered the foundations and advanced patterns of Rhino's override system. Now let's put it all together with a complete walkthrough: we'll override the application shell and replace the default table view with a beautiful card-based grid.
This walkthrough demonstrates the copy-adapt-wire workflow in practice with real, production-ready code you can use in your own projects.
Synthetic attributes are one of Rhino's most powerful yet underutilized features, allowing you to create computed properties that enhance your API responses without cluttering your database. In this comprehensive guide, we'll explore how to implement synthetic attributes in a real-world blog application, demonstrating their practical benefits and advanced usage patterns.
One of the toughest parts of building an MVP isn't coming up with the idea, it's getting something functional out the door without drowning in boilerplate code. Every hour spent writing controllers, setting up authentication, and plugging in authorization logic is an hour not spent validating the actual product. Rhino exists to cut that overhead. It's an abstraction layer on top of Ruby on Rails designed specifically to help you move fast, handle the boring parts, and still leave room for custom logic when you need it.
Rhino provides robust core authorization and authentication through its policy system. While the default CrudPolicy and role-based policies (AdminPolicy, EditorPolicy, ViewerPolicy) handle most scenarios, some applications require fine-grained, permission-based authorization where individual actions are explicitly granted or denied based on a permissions table.
This guide will explore how to extend Rhino's authorization system with custom permissions while leveraging the existing policy architecture.
The Rhino Notifications module (rhino_project_notifications) is a Rails engine that wraps and extends the activity_notification gem (v2.3.3) to provide a complete notification system for Rhino-based applications. It provides both backend (Rails API) and frontend (React) components for managing user notifications.
This guide will first explain the base activity_notification gem capabilities, then detail what Rhino adds on top, and finally walk through setup and usage.
DevContainers (Development Containers) are a standardized way to define and manage development environments using Docker containers. They encapsulate an entire development toolchain into a single, self-contained unit, providing a consistent, reproducible, and isolated environment that works seamlessly across different machines and operating systems.
In the context of the Rhino project, devcontainers are crucial for eliminating the classic "it works on my machine" problem. By ensuring that all developers, whether working on macOS, Windows, or Linux use an identical set of tools, dependencies, and configurations, we streamline collaboration and reduce environment-related bugs.
In modern web applications, offloading time-consuming tasks to background jobs is essential for maintaining responsiveness and a smooth user experience. The Rhino framework, a powerful Rails + React solution, provides a robust, built-in system for handling these asynchronous operations. This article delves into Rhino's job queue architecture.