Render versioned views automagically based on the clients requested version.
Provides Holder.js to render image placeholders entirely on the client side
ZiYa allows you to easily create interactive charts, gauges and maps for your web applications. ZiYa leverages flash which offload heavy server side processing to the client. At the root ZiYa allows you to easily generate an XML files that will be downloaded to the client for rendering. Using this gem, you will be able to easily create great looking charts for your application. You will also be able to use the charts, gauges and maps has a navigation scheme by embedding various link in the graphical components thus bringing to the table an ideal scheme for reporting and dashboard like applications. Your manager will love you for it !! Sample site : http://ziya.liquidrail.com Documentation : http://ziya.liquidrail.com/docs Forum : http://groups.google.com/group/ziya-plugin Repositories : git://github.com/derailed/ziya.git
Adds a #flush helper to Rails which flushes the output buffer to the client before the template has finished rendering.
Ruby client for the HTML/CSS to Image API. Generate PNG, JPG, WebP, or PDF images and MP4, WebM, or GIF recordings with Ruby. Renders exactly like Google Chrome.
Shows you the source location of a server-side or client-side rendered DOM element. Works with Rails 3 and 4
Client and Rack Middlware which submits URL's and HTML fragments to be rendered as a PDF
This is a TeX-to-HTML+MathML+CSS converter class using the Javascript-based KaTeX, interpreted by one of the Javascript engines supported by ExecJS. The intended purpose is to eliminate the need for math-rendering Javascript in the client's HTML browser. Therefore the name: SsKaTeX means Server-side KaTeX. Javascript execution context initialization can be done once and then reused for formula renderings with the same general configuration. As a result, the performance is reasonable. The configuration supports arbitrary locations of the external file katex.min.js as well as custom Javascript for pre- and postprocessing. For that reason, the configuration must not be left to untrusted users.
Render shared views on the client OR on the server
Email clients are not web browsers. They render html all funny, to put it politely. In general, the best practices for writing HTML that will look good in an email are the exact inverse from those that you should use for a web page. Remembering all those differences sucks.
== FEATURES/PROBLEMS: * Parses the Rails log. * Recognises Processing...Completed blocks. * Recognises Processing...exception...Rendering rescue blocks. * Collects the fluff between Processing blocks too. * Does as little interpretation of the parsed requests as possible. This is left up to the client. * Needs better doco. * Needs Rails 2.0 format support. == SYNOPSIS: require 'rubygems' require 'ringbarker' @parser = Ringbarker::Parser.new @entries = []
Client library to pull and render INK views.
RJS is a great Ruby DSL to write javascript. However, it's so tempting to write RJS directly in the views, and soon the views contain substantial controller knowledge (e.g. link_to_remote, link_to, etc) KRJS attempts to solve that problem by allowing dynamic inclusion of AJAX calls on HTML elements. When a controller defines a method (based on naming convention) that handles a client-side event, the rendering engine will do the wiring automatically - when the event happens, an AJAX call will be made to the controller's method which would ideally reply with RJS and update portions of the document.
Small CLI client for rendering a pomodoro timer
This gem provides access to the client side rendering application JSC3D
RJS is a great Ruby DSL to write javascript. However, it's so tempting to write RJS directly in the views, and soon the views contain substantial controller knowledge (e.g. link_to_remote, link_to, etc) KRJS attempts to solve that problem by allowing dynamic inclusion of AJAX calls on HTML elements. When a controller defines a method (based on naming convention) that handles a client-side event, the rendering engine will do the wiring automatically - when the event happens, an AJAX call will be made to the controller's method which would ideally reply with RJS and update portions of the document.
WebScraping.AI provides LLM-powered web scraping with Chromium JavaScript rendering, rotating proxies, and built-in HTML parsing. This gem is the official Ruby client.
All the advantages of client-side components, but with minimal Javascript plus server-side rendering
Provides a Ruby client to interact with a Cenit API using a DSL to route your resources and to build queries and options for result rendering.
+js-rails-routes+ is a utility for generating JavaScript equivalents to the +<route>_path+ functions provided by {Ruby on Rails}[https://github.com/rails/rails]. This allows you to do very similar things in your {+ejs+}[https://rubygems.org/gems/ejs/] JavaScript templates as you would in your +erb+ ruby templates. You can move html rendering to the client and keep it looking very similar to how it would look on the server. For example, if you have a model +Item+ and a simple route to list all the items, a link to that items page (using an explicit +a+ anchor tag instead of the Rails +link_to+) would look the same in either an +erb+ file or an +ejs+ file: <a href="<%= items_path() %>">List all Items</a> This gem was originally developed as part of the {MVCoffee}[http://mvcoffee.org] suite of tools, and integrates strongly with the {mvcoffee.js}[https://github.com/kirkbowers/mvcoffee] CoffeeScript MVC framework.
Dynamically rescue errors and render a structured JSON response to client applications
Render videos programmatically with the iLoveVideoEditor cloud video API: submit JSON scenes or render templates with variables, queue render jobs, and download the resulting MP4/WebM. Provides a high-level client with blocking renders, polling and progress callbacks, plus the full auto-generated OpenAPI client for every endpoint. Requires Ruby 3.0 or later.
RespondoGrpc standardizes the responses your gRPC services send. Every rpc can return one protobuf envelope (respondo.v1.Response: success, message, data, errors, meta), built from the same expressive helpers as its siblings (render_grpc_ok, render_grpc_not_found, render_grpc_unprocessable, ...). Failures finish the call with the matching gRPC status code (NOT_FOUND, INVALID_ARGUMENT, ...) and carry the envelope in the trailing metadata, so clients get both a proper status and structured field errors. Protobuf messages travel as typed payloads, hashes and ActiveRecord records as JSON-like data. Standalone gem — it does not depend on respondo (JSON) or respondo-graphql.
Ruby client for the ShotWolf API - capture screenshots, render device mockups, generate Open Graph cards, convert HTML to PDF, and run pixel-level visual regression diffs through a single JSON HTTP API. Zero dependencies.
Official Ruby client for URLpipe. Get a page's Markdown, rendered HTML, a full-page screenshot, a PDF, metadata, a summary, keywords, structured data, console errors or a Lighthouse audit, rendered in real Chrome. Handles long analyses, retries with idempotency keys, and webhook signature verification. No runtime dependencies.
The agent-interop gem of Poetry, the AI-native frontend framework for Rails. Five surfaces: the boot-free poetry-agent MCP server (the component contract over Model Context Protocol, with runtime skill delivery); the WebMCP runtime that registers rendered components' declared tools with in-browser agents (document.modelContext) behind safe-by-default, opt-in registration, declarative forms, and an origin-trial middleware; the AG-UI relay, a Rails client of the Agent-User Interaction protocol that runs an agent and relays its events as Turbo Streams, with frontend tools and interrupts; the A2UI catalog projected from the component registry; and the A2UI renderer that folds the envelope into server-rendered surfaces with forms, checks, functions, and morphing updates.
Magik is a full-stack Ruby framework designed for TruffleRuby: one DSL for models, screens, actions, realtime channels, background jobs, ledgers, APIs and admin panels. The server renders HTML and htmx handles interactivity — there is no separate frontend framework, no offline mode, and no heavy client-side compute. Status as of 2026-08-26: this is a name-reservation release. The specification lives in docs/idea/00-build-spec.md and is entirely unimplemented. What ships today is the gem skeleton, the MAGIK_* error-code convention, a `magik version` / `magik help` CLI, and one documented, spec-only stub module per planned subsystem. Nothing renders a page, connects to a database, or runs a job yet.
Render HTML and CSS to images, capture screenshots of live URLs, render named templates and export A4 PDFs, all in real Chrome. Zero runtime dependencies.
Rack middleware + Rails integration for Shugoi. Blocks bots, scrapers and headless clients with a proof-of-work challenge, environment signals and split-render, mirroring the Node.js module.
A minimal MCP (Model Context Protocol) server that exposes ask_web_fetch as a callable tool over stdio. Designed for use with clients that support MCP (ZCode, Claude Code, etc.), it fetches a URL and returns clean markdown through the ask-web-fetch backend chain — fast pure-Ruby httpx fetch first, a real Chrome (launched or CDP-attached) for JS-rendered and challenge-gated pages, with Jina Reader and self-hosted Crawl4AI in between. Terminal failures (parked domains, empty pages, dead 4xx) surface as their deterministic error class, so clients never retry the unretryable. The tool shell (name, schema, call) lives here, wrapping the Ask::WebFetch library.
phlex-reactive makes Phlex components reactive without writing Stimulus controllers or hand-picking Turbo Stream targets. Declare actions in Ruby; a single generic client runtime turns clicks and form input into a server round trip that re-renders the component and morphs it back in. Components self-target by a stable DOM id, so the same unit re-renders for client actions AND server-pushed broadcasts. State lives in the database behind a signed identity — no attacker-controlled snapshot. Pairs with pgbus for reliable, transactional, reconnect-safe live updates with no Action Cable and no Redis.
Official Ruby client for Poli Page. Renders PDFs, previews, and thumbnails via api.poli.page.
Ruby client for the Rerout API — create short links, render QR codes, read analytics, and verify webhook signatures. Built on Faraday with an injectable connection for tests and edge deployments.
Ruby client library for rendering and downloading documents from SP Docgen
Client-side rendering and state management for ViewComponent.
Rhales is a framework for building server-rendered components with client-side data hydration using .rue files called RSFCs (Ruby Single File Components). Similar to Vue.js single file components but for server-side Ruby applications. Features include Handlebars-style templating, JSON data injection, partial support, pluggable authentication adapters, and security-first design.