HTML-Aware ERB: The Path to Reactive Rendering @ RubyKaigi 2026, Hakodate, Japan

ERB templates in Ruby are traditionally rendered by engines that treat templates as string generators, which makes it difficult to reason about HTML structure, state changes, or incremental updates. These limitations become especially visible in modern HTML-over-the-wire workflows.

In this talk, we explore what it would take to build a reactive ERB rendering engine. We begin by revisiting how existing ERB engines compile templates into Ruby code and look at how recent advances in HTML-aware parsing and tooling make new approaches possible.

Using Herb::Engine as a concrete example, we examine how structural understanding enables state-aware rendering, diff-based updates, and a more responsive development experience, including instant updates without full page reloads and rich in-browser developer tools. Such as template outlines, partial and ERB structure views, jump-to-source navigation, and many other innovations.

https://rubykaigi.org/2026/presentations/marcoroth.html

Transcript

1. Marco Roth HTML-Aware ERB: The Path to Reactive Rendering April 24, 2026 - RubyKaigi 2026
2. Marco Roth !  @marcoroth_  @marcoroth@ruby.social 🌐 marcoroth.dev  @marcoroth Full-Stack Developer & Open Source Contributor  @marcoroth.dev
4. Developer Tooling & Developer Experience
5. ERB
6. Embedded Ruby
7. ERB is versatile
8. <div> <span><%= @user.firstname %></span> <b><%= @user.lastname %></b> </div> <div> <span><%= @user.firstname %></span> <b><%= @user.lastname %></b> </div>
9. HTML+ERB
11. Empowering Developers with HTML-Aware ERB Tooling Marco Roth April 16, RubyKaigi 2025
12. HTML+ERB
13. HTML+ERB HTML+ERB
14. Herb
15. Herb Parser
17. Herb Toolchain
20. HTML-Aware ERB: The Path to Reactive Rendering
21. ERB Engines Reactivity What's missing?
22. Herb
23. Rails just works. And it keeps working.
24. Challenge: How do you innovate without breaking what already works?
25. The New Wave of Ruby DX
26. Major Ruby DX Events Since Ruby 3.0 2021 2022 2023 2024 2026 2025/11/06 Ruby 3.0 (release) 2025 repl_type_completor (release) Tomoya Ishida RubyWorld Conference 2025 Steep (v1.0 release) Soutaro Matsumoto debug.gem (release)
 Koichi Sasada RDoc modernization IRB & Reline transformation Tomoya Ishida Mari Imaizumi
 Hitoshi Hasumi Herb (release) Marco Roth Prism (release) Kevin Newton Ruby LSP (release) Vini Stock RBS in Sorbet Alexandre Terrasa
 Alexander Momchilov rbs-inline (release) Soutaro Matsumoto https://github.com/st0012/slides/tree/main/2025-11-06-ruby-world-conference
27. Importance of Shared Infrastructure RubyWorld Conference 2025 2025/11/06 Prism Herb repl_type_completor Ruby LSP Sorbet RuboCop RDoc (Experimental/WIP) Steep RBS https://github.com/st0012/slides/tree/main/2025-11-06-ruby-world-conference
28. But there's one spot that hasn't been touched yet.
29. The View Layer
30. Why Tooling Never Existed?
31. Because there was nothing to build against.
32. There was no parser like Prism to build these kind of tools
33. The question is ...
34. What becomes possible when the ERB engine/runtime also understands HTML?
35. What if we established an HTML+ERB grammar?
36. A formal syntax to define what's valid and invalid
37. Provide structure, hierarchy, and HTML-awareness that tools can understand and reason about
38. Ruby Prism Parser
39. Herb Parser (HTML+ERB structure) + Prism (Ruby grammar) = Full validation before runtime
40. Missing <% end %>? → Herb + Prism catch it at parse time Invalid Ruby syntax? → Prism catches it at parse time Unclosed HTML tag? → Herb catches it at parse time
41. Establishing the grammar is what makes everything else possible.
42. Herb
43. A grammar.
44. A grammar. A parser.
45. A grammar. A parser. A full toolchain for HTML+ERB.
46. This is what was missing.
47. The language definition and the grammer itself
48. One parser. One truth.
50. This is really powerful.
51. If your editor tells you there is an error, you don't have to run the code to find out
52. Because its powered by the same underlying architecture
58. Diagnostics Linter Formatter Document Highlights Support Code Actions Folding Ranges Smart Comment Toggling
59. ERB Engines
60. ERB templates are Ruby
61. ERB templates are Ruby ... almost
62. ERB → Ruby
63. ERB templates ↓ ERB Engine/Compiler ↓ Ruby Code
64. Erubi::Engine
65. <h1>Hello, <%= name %>!</h1
66. <h1>Hello, <%= name %>!</h1 Regex ↓ <h1>Hello, <%= name %>!</h1
67. <h1>Hello, <%= name %>!</h1 <h1>Hello, <%= name %> !</h1 Regex ↓
68. <h1>Hello, <%= name %>!</h1 "<h1>Hello, " name "!</h1" Regex ↓
69. "<h1>Hello, " name "!</h1"
70. "<h1>Hello, " name "!</h1"
71. "<h1>Hello, " name "!</h1" add_text("<h1>Hello, ")
72. "<h1>Hello, " name "!</h1" add_text("<h1>Hello, ") add_expression("name")
73. "<h1>Hello, " name "!</h1" add_text("<h1>Hello, ") add_expression("name") add_text("!</h1")
74. "<h1>Hello, " name "!</h1" add_text("<h1>Hello, ") add_expression("name") add_text("!</h1")
75. add_text("<h1>Hello, ") add_expression("name") add_text("!</h1")
76. _buf = ::String.new _buf << '<h1>Hello, ' _buf << ::Erubi.h(name) _buf << '!</h1' _buf.to_s (simplified+formatted)
77. eval(" _buf = ::String.new _buf << '<h1>Hello, ' _buf << ::Erubi.h(name) _buf << '!</h1' _buf.to_s ")
78. eval(" _buf = ::String.new _buf << '<h1>Hello, ' _buf << ::Erubi.h(name) _buf << '!</h1' _buf.to_s ") => "<h1>Hello RubyKaigi!</h1"
79. "<h1>Hello RubyKaigi!</h1" ↓ <h1>Hello, <%= name %>!</h1
81. We want to make our Engine aware of HTML
82. We need this so we can reason about the HTML and to enable reactivity
83. ERB Engine HTML+ERB Engine ↓
84. String Templating HTML Templating ↓
85. ::Engine Herb
87. HTML-aware ERB Rendering Engine
88. Erubi::Engine API-compatible
89. <h1>Hello, <%= name %>!</h1>
90. Herb.parse("<h1>...</h1>")
91. @ DocumentNode └── children: (1 item) └── @ HTMLElementNode ├── open_tag: │ └── @ HTMLOpenTagNode │ ├── tag_opening: "<" │ ├── tag_name: "h1" │ └── tag_closing: ">" │ ├── tag_name: "h1" ├── body: (3 items) │ ├── @ HTMLTextNode │ │ └── content: "Hello, " │ │ │ ├── @ ERBContentNode │ │ ├── tag_opening: "<%=" │ │ ├── content: " name " │ │ └── tag_closing: "%>" │ │ │ └── @ HTMLTextNode │ └── content: "!" │ └── close_tag: └── @ HTMLCloseTagNode ├── tag_opening: "</" ├── tag_name: "h1" └── tag_closing: ">"
92. @ DocumentNode └── children: (1 item) └── @ HTMLElementNode ├── open_tag: │ └── @ HTMLOpenTagNode (<h1>) │ ├── body: (3 items) │ ├── @ HTMLTextNode ("Hello, ") │ ├── @ ERBContentNode (<%= name %>) │ └── @ HTMLTextNode ("!") │ └── close_tag: └── @ HTMLCloseTagNode (</h1>)
93. class Compiler < Herb::Visitor def visit_document_node(node) def visit_html_element_node(node) def visit_html_open_tag_node(node) def visit_html_close_tag_node(node) def visit_html_text_node(node) def visit_erb_content_node(node) end
94. def visit_html_open_tag_node(node) add_text(node.tag_opening) add_text(node.tag_name) add_text(node.tag_closing) end @ HTMLOpenTagNode ├── tag_opening: "<" ├── tag_name: "h1" └── tag_closing: ">"
95. def visit_html_text_node(node) add_text(node.content) end @ HTMLTextNode └── content: "Hello, "
96. @ ERBContentNode ├── tag_opening: "<%=" ├── content: " name " └── tag_closing: "%>" def visit_erb_content_node(node) if node.tag_opening == "<%=" add_expression(node.content) else add_code(node.content) end end
97. add_text("<") add_text("h1") add_text(">") add_text("Hello, ") add_expression("name") add_text("!") add_text("</") add_text("h1") add_text(">")
98. add_text("<") add_text("h1") add_text(">") add_text("Hello, ") add_expression("name") add_text("!") add_text("</") add_text("h1") add_text(">") add_text("<h1>Hello, ") add_expression("name") add_text("!</h1>") Erubi::Engine Herb::Engine
99. def add_text(text) @tokens << [:text, text] end def add_expression(code) @tokens << [:expr, code] end def add_code(code) @tokens << [:code, code] end
100. add_text("<") add_text("h1") add_text(">") add_text("Hello, ") add_expression("name") add_text("!") add_text("</") add_text("h1") add_text(">")
101. @tokens = [ ["<", :text], ["h1", :text], [">", :text], ["Hello, ", :text], ["name", :expr], ["!", :text], ["</", :text], ["h1", :text], [">", :text], ]
102. @tokens = [ ["<", :text], ["h1", :text], [">", :text], ["Hello, ", :text], ["name", :expr], ["!", :text], ["</", :text], ["h1", :text], [">", :text], ]
103. @tokens = [ ["<h1>Hello, ", :text], ["name", :expr], ["!</h1>", :text], ]
104. @tokens = [ ["<h1>Hello, ", :text], ["name", :expr], ["!</h1>", :text], ]
105. @tokens = [ ["<h1>Hello, ", :text], ["name", :expr], ["!</h1>", :text], ] add_text("<h1>Hello, ") add_expression("name") add_text("!</h1")
106. add_text("<h1>Hello, ") add_expression("name") add_text("!</h1>") Erubi::Engine Herb::Engine add_text("<h1>Hello, ") add_expression("name") add_text("!</h1>")
107. _buf = ::String.new _buf << '<h1>Hello, ' _buf << ::Erubi.h(name) _buf << '!</h1>' _buf.to_s (simplified+formatted) _buf = ::String.new _buf << '<h1>Hello, ' _buf << ::Herb.h(name) _buf << '!</h1>' _buf.to_s Erubi::Engine Herb::Engine
108. Gives us all the guarantees the Herb Parser gives us
109. Ensures valid HTML Templates and Syntax
110. String Templating Engine HTML Templating Engine ↓
111. With all this knowledge we can also start to tackle more ambitious things
113. Since we control the rendering now
114. We can inject additional HTML markup in development
123. So where do we go from here?
124. What else do we need?
125. What if we could complete the Hotwire story?
126. And how would that look like?
127. What if Ruby apps could have...
128. → Reactivity → Optimistic UI updates → Offline functionality → Lazy loading driven by the template → Instant interactions without full reloads → Beautiful, modern UX → Component-driven deferred rendering
129. Without having to abandon server-rendered HTML?
130. Without having to write Single Page Applications
131. Without having to give up on full-stack Ruby?
132. Reactivity
133. Production Reactivity Dev-Time Reactivity
134. Production Reactivity
135. The Reactivity Landscape
136. JavaScript: → React (Virtual DOM) → Svelte (compile-time) → Solid (signals)
137. Elixir: Phoenix LiveView + HEEx + LiveEEx → slot-level change tracking
138. PHP: Laravel Livewire + Blade + Blaze
139. What do these frameworks have in common?
140. The engine understands what it's rendering.
141. It has a graph of dependencies.
142. That graph is what enables fine-grained reactivity.
143. We never had something like this in Ruby.
144. Look beyond our own ecosystem.
145. See what others do well. Understand why it works. Bring it back. The Ruby way.
148. The Goal
149. Keep what's great. Add what's missing. No JavaScript framework.
150. With the goal of making it as backwards compatible as possible
151. So all existing .html.erb files keep working and get an upgrade
152. The Idea
153. <ul> <% @items.each do |item| %> <li><%= item %></li> <% end %> </ul> @items = [1, 2, 3] <ul> <li>1</li> <li>2</li> <li>3</li> </ul> State View Template Rendered View Log Initial view rendered
154. <ul> <% @items.each do |item| %> <li><%= item %></li> <% end %> </ul> @items = [1, 2, 3, 4] <ul> <li>1</li> <li>2</li> <li>3</li> </ul> State View Template Rendered View Log Initial view rendered @items state changed
155. <ul> <% @items.each do |item| %> <li><%= item %></li> <% end %> </ul> <ul> <li>1</li> <li>2</li> <li>3</li> </ul> State View Template Rendered View Log Initial view rendered @items state changed re-rendering view @items = [1, 2, 3, 4]
156. <ul> <li>1</li> <li>2</li> <li>3</li> </ul> State View Template Rendered View Log Initial view rendered @items state changed re-rendering view tracing dependencies <ul> <% @items.each do |item| %> <li><%= item %></li> <% end %> </ul> @items = [1, 2, 3, 4]
157. <ul> <% @items.each do |item| %> <li><%= item %></li> <% end %> </ul> <ul> <li>1</li> <li>2</li> <li>3</li> </ul> State View Template Rendered View Log Initial view rendered @items state changed re-rendering view tracing dependencies render delta for item `4` @items = [1, 2, 3, 4]
158. <ul> <% @items.each do |item| %> <li><%= item %></li> <% end %> </ul> @items = [1, 2, 3, 4] <ul> <li>1</li> <li>2</li> <li>3</li> </ul> State View Template Rendered View Log Initial view rendered @items state changed re-rendering view tracing dependencies render delta for item `4` <li>4</li>
159. <ul> <% @items.each do |item| %> <li><%= item %></li> <% end %> </ul> @items = [1, 2, 3, 4] <ul> <li>1</li> <li>2</li> <li>3</li> </ul> State View Template Rendered View Log Initial view rendered @items state changed re-rendering view tracing dependencies render delta for item `4` <li>4</li>
160. <ul> <% @items.each do |item| %> <li><%= item %></li> <% end %> </ul> @items = [1, 2, 3, 4] <ul> <li>1</li> <li>2</li> <li>3</li> </ul> State View Template Rendered View Log Initial view rendered @items state changed re-rendering view tracing dependencies render delta for item `4` apply delta to view <li>4</li>
161. <ul> <% @items.each do |item| %> <li><%= item %></li> <% end %> </ul> @items = [1, 2, 3, 4] <ul> <li>1</li> <li>2</li> <li>3</li> <li>4</li> </ul> State View Template Rendered View Log Initial view rendered @items state changed re-rendering view tracing dependencies render delta for item `4` apply delta to view
162. We need to understand what's in the template
163. What Control Flow Structures are used
164. What state is available
165. How data flows
166. The missing piece for this was the grammar and the parser
167. Herb HTML+ERB Parser Prism Ruby Parser
168. How can we make reactivity happen?
169. Source: https://books.writesoftwarewell.com/10/hotwire-handbook/165/traditional-web-architecture
170. app/views/profiles/show.html.erb GET /profiles/:slug ↓ ProfilesController#show ↓
171. → request → controller → layout → view → partials → nested partials
172. Challenge 1: Understand the render graph
173. <div class="container py-8"> <%= render partial: "profiles/header", locals: { user: @user } %> <%= render partial: "profiles/topics", locals: { topics: @topics } %> <%= render partial: "profiles/navigation" %> <div class="mt-6"> <% if @talks.any? %> <%= render partial: "profiles/talks", locals: { talks: @talks } %> <% else %> <%= render partial: "profiles/events", locals: { events: @events } %> <% end %> </div> </div> app/views/profiles/show.html.erb
174. <div class="container py-8"> <%= render partial: "profiles/header", locals: { user: @user } %> <%= render partial: "profiles/topics", locals: { topics: @topics } %> <%= render partial: "profiles/navigation" %> <div class="mt-6"> <% if @talks.any? %> <%= render partial: "profiles/talks", locals: { talks: @talks } %> <% else %> <%= render partial: "profiles/events", locals: { events: @events } %> <% end %> </div> </div>
175. <%= render partial: "profiles/header", locals: { user: @user } %> @ ERBRenderNode (location: (1:0)-(1:65)) └── keywords: └── @ RubyRenderKeywordsNode (location: (1:0)-(1:65)) ├── errors: [] ├── partial: "profiles/header" (location: (1:20)-(1:37)) ├── template_path: ∅ ├── inline_template: ∅ ├── body: ∅ ├── plain: ∅ ├── html: ∅ ├── renderable: ∅ ├── collection: ∅ ├── as_name: ∅ ├── spacer_template: ∅ ├── variants: ∅ └── locals: (1 item) └── @ RubyRenderLocalNode (location: (1:49)-(1:60)) ├── errors: [] ├── name: "user" (location: (1:49)-(1:54)) └── value: └── @ RubyLiteralNode (location: (1:55)-(1:60)) ├── errors: [] └── content: "@user"
176. <%= render partial: "profiles/header", locals: { user: @user } %> @ ERBRenderNode (location: (1:0)-(1:65)) └── keywords: └── @ RubyRenderKeywordsNode (location: (1:0)-(1:65)) ├── errors: [] ├── partial: "profiles/header" (location: (1:20)-(1:37)) ├── template_path: ∅ ├── inline_template: ∅ ├── body: ∅ ├── plain: ∅ ├── html: ∅ ├── renderable: ∅ ├── collection: ∅ ├── as_name: ∅ ├── spacer_template: ∅ ├── variants: ∅ └── locals: (1 item) └── @ RubyRenderLocalNode (location: (1:49)-(1:60)) ├── errors: [] ├── name: "user" (location: (1:49)-(1:54)) └── value: └── @ RubyLiteralNode (location: (1:55)-(1:60)) ├── errors: [] └── content: "@user"
177. Which files are being rendered when rendering profiles/show?
179. Where is this partial being rendered from?
181. Since we have the full understanding of the views
183. Challenge 2: Trace state dependencies
184. ERB is surprisingly well-suited for this
185. Every ERB tag has a simple contract
186. <ul> <% @items.each do |item| %> <li><%= item %></li> <% end %> </ul>
187. _buf = ::String.new; _buf << '<ul>' @items.each do |item| _buf << '<li>' _buf << item.to_s _buf << '</li>' end _buf << '</ul>' _buf.to_s <ul> <% @items.each do |item| %> <li> <%= item %> </li> <% end %> </ul>
188. _buf = ::String.new; _buf << '<ul>' @items.each do |item| _buf << '<li>' _buf << item.to_s _buf << '</li>' end _buf << '</ul>' _buf.to_s <ul> <% @items.each do |item| %> <li> <%= item %> </li> <% end %> </ul>
189. <%= item %> _buf << (item).to_s
190. <%= .... %> _buf << (....).to_s
191. It takes some state in and it produces a string out
192. When you render an ERB template you get a String as a result
193. This allows us to build out reactivity
194. Challenge 3: Local variables vs. helpers
195. <% if user.present? %> <%= link_to "Show", user_path(user) %> <% end %>
196. <% if user.present? %> <%= link_to "Show", user_path(user) %> <% end %>
197. Locals? Path Helpers? App View Helpers? Action View Tag Helpers?
199. Find all locals, instance variables, app helpers, etc. using Prism
200. Action View Helper Registry
201. All references - strict locals - path helpers - app view helpers - Action View Helpers = unresolved references
202. ~ Approximation
203. For reactivity to work, we need to be able to resolve all references
204. But this can be gradual and on a per-route basis
205. or only on the pages where you need high fidelity and high reactivity
206. For unresolved references we can show warnings
210. Define Strict Locals Expose another way for explicit declaration
211. The beautiful thing is that help you resolve these issues because we have the full understanding
212. Challenge 4: Action View Tag Helpers
213. <%= turbo_frame_tag dom_id(@post) do %> <%= tag.div data: { controller: "hello" } do %> <%= link_to @post.title, post_path(@post) %> <% end %> <% end %>
214. What needs to be re-rendered when @post changes?
215. <%= turbo_frame_tag dom_id(@post) do %> <%= tag.div data: { controller: "hello" } do %> <%= link_to @post.title, post_path(@post) %> <% end %> <% end %>
216. <%= turbo_frame_tag dom_id(@post) do %> <%= tag.div data: { controller: "hello" } do %> <%= link_to @post.title, post_path(@post) %> <% end %> <% end %>
217. <%= .... %> _buf << (....).to_s
218. <%= turbo_frame_tag dom_id(@post) do %> <%= tag.div data: { controller: "hello" } do %> <%= link_to @post.title, post_path(@post) %> <% end %> <% end %>
219. <%= turbo_frame_tag dom_id(@post) do %> <%= tag.div data: { controller: "hello" } do %> <%= link_to @post.title, post_path(@post) %> <% end %> <% end %>
220. <%= turbo_frame_tag dom_id(@post) do %> <%= tag.div data: { controller: "hello" } do %> <%= link_to @post.title, post_path(@post) %> <% end %> <% end %>
221. <%= turbo_frame_tag dom_id(@post) do %> <%= tag.div data: { controller: "hello" } do %> <%= link_to @post.title, post_path(@post) %> <% end %> <% end %>
222. We would need to re-render the whole template
223. Herb now supports Action View Tag Helpers detection
224. <%= turbo_frame_tag dom_id(@post) do %> <%= tag.div data: { controller: "hello" } do %> <%= link_to @post.title, post_path(@post) %> <% end %> <% end %>
225. <turbo-frame id="<%= dom_id(@post) %>"> <div data-controller="hello"> <a href="<%= post_path(@post) %>"> <%= @post.title %> </a> </div> </turbo-frame>
226. <turbo-frame id="<%= dom_id(@post) %>"> <div data-controller="hello"> <a href="<%= post_path(@post) %>"> <%= @post.title %> </a> </div> </turbo-frame>
227. <%= turbo_frame_tag dom_id(@post) do %> <%= tag.div data: { controller: "hello" } do %> <%= link_to @post.title, post_path(@post) %> <% end %> <% end %>
228. This is going to allow fine-grained reactivity
230. Challenge 5: Track which reference affect which DOM nodes
231. Reverse Dependency Index
232. <h1><%= @post.title.upcase %></h1> <% if @user.admin? %> <p><%= @user.id %></p> <% end %> <%= link_to @post.title, post_path(@post) %>
233. <h1><%= @post.title.upcase %></h1> <% if @user.admin? %> <p><%= @user.id %></p> <% end %> <%= link_to @post.title, post_path(@post) %>
234. <h1><%= @post.title.upcase %></h1> <% if @user.admin? %> <p><%= @user.id %></p> <% end %> <%= link_to @post.title, post_path(@post) %>
235. <h1><%= @post.title.upcase %></h1> <% if @user.admin? %> <p><%= @user.id %></p> <% end %> <%= link_to @post.title, post_path(@post) %>
236. @post => [ "<h1><%= @post.title.upcase %></h1>", "<%= link_to @post.title, post_path(@post) %>" ] @user => [ "<% if @user.admin? %>", "<p><%= @user.id %></p>" ]
237. This allows us to compute the minimal changes needed to reflect a state change in the UI
238. What Herb knows: ✓ ~250 ActionView helpers (via registry) ✓ Strict locals declarations ✓ Locals passed through render calls ✓ Instance variables (@post, @user) ✓ Constants (Current.user, Post.count)
239. What Herb knows: ✓ Understand the render graph ✓ Trace state dependencies ✓ Resolving Action View Tag Helpers ✓ Track which variables affect which DOM nodes
240. We aren't quite there yet for production reactivity
241. But this gives us all the primitives and foundation to build out this vision
242. Now all of these primitives need to be wired up
243. Where we can have Phoenix LivewView-like server-side reactivity in Ruby
245. Dev-Time Reactivity
246. Vite Dev Server webpack-dev-server
247. Update the view file and the updates get reflected automatically
248. Without a full page reload and re-render of the page
249. Herb Syntax Tree Diffing Engine
250. Herb.diff(old_source, new_source)
252. https://github.com/marcoroth/herb/pull/1518
253. <div>Hello World</div> ↓
254. <div>Hello World</div> <div>Hello Ruby</div> ↓
255. <div>Hello World</div> <div>Hello Ruby</div> ↓
256. <h1><%= title %></h1> ↓
257. <h1><%= title %></h1> <h1 class="title"><%= title %></h1> ↓
258. <h1><%= title %></h1> <h1 class="title"><%= title %></h1> ↓
259. This also works for HTML Elements, ERB Content etc.
260. And you might already be able to see where this is going!
261. Herb Dev Server
262. Hot Reloading in Development
263. herb dev
264. herb dev
265. Uses Herb.diff to get the diff between the old and the new version
266. herb dev
273. No full page refresh
274. Just incremental updates emitted by the Herb Diff Engine
275. Bonus: Compile Time Optimizations
276. These improvements are side-effects of the work we needed for reactivity
277. Compile-time optimizations for Action View Tag helpers
278. <%= turbo_frame_tag dom_id(@post) do %> <%= tag.div data: { controller: "hello" } do %> <%= link_to @post.title, post_path(@post) %> <% end %> <% end %> <turbo-frame id="<%= dom_id(@post) %>"> <div data-controller="hello"> <a href="<%= post_path(@post) %>"> <%= @post.title %> </a> </div> </turbo-frame> ↓
279. These are early benchmarks, take them with a grain of salt
281. Render Call Optimizations/Inlining
283. Some of these results sound too good to be true, but I'm sure there is some performance to be gained
284. Conclusion
285. I hope this talk has given an overview of Herb and its potential
286. And how we are trying to achieve the path Reactivity in ERB
287. The Ruby Prism Parser had a big effect on Ruby internals and the tooling landscape
288. Herb can have a similar effect for HTML Templating and Tooling.
292. With the Herb Toolchain as the foundation reactivity now feels doable.
293. I think reactivity is the missing piece to complete the Hotwire story.
294. So that we can keep writing Ruby
295. and build ambitious web applications with even less complexity
296. Herb v0.10 ships the primitives and foundation for reactivity in ReActionView
297. Acknowledgments
298. Thank you to everyone who tried Herb and reported issues
300. github.com/sponsors/marcoroth 
302. https://gem.coop/updates/2026-fellowship/
303. Please try the tools, report issues, and give feedback.
305. herb-tools.dev
306. Thank you "  @marcoroth_  @marcoroth@ruby.social 🌐 marcoroth.dev  @marcoroth  @marcoroth.dev  /in/marco-roth