The Modern View Layer Rails Deserves: A Vision For 2025 And Beyond @ SF Bay Area Ruby Meetup, July 2025

Abstract

Rails revolutionized web development and continues to evolve, but its view layer has remained largely unchanged while frontend needs have evolved dramatically. Rails has maintained its relevance by adopting technologies like Turbolinks and now Turbo/Hotwire while preserving its core principles.

But today's developers face challenges the current view layer wasn't designed to solve: complex UI interactions, reactivity, robust tooling for large codebases, intergration with modern UI kits, and modern tooling expectations.

This talk explores how a new HTML-aware ERB parser (Herb) could enable a truly reactive Rails view layer, bringing LiveView-style reactivity while preserving the "HTML-over-the-wire" philosophy. It will integrate with existing LSPs, unlock powerful tooling, and enable reactive server-rendered templates that could be reused client-side.

I'll demonstrate what's possible through proof-of-concepts and early prototypes, showing how we can collectively advance Rails views for modern development.

Details

This session shares the vision of "ReActionView - Reactive ActionView" - a modern approach for ActionView built on Herb, designed to meet today's frontend demands while maintaining Rails' principles.

Content

Today's Challenges: Why Rails views need better tooling in the HTML-over-the-wire era
The Foundation: How Herb opens new possibilities by understanding both HTML and ERB simultaneously
Developer Experience: Seamless integration with Ruby, Rails, Stimulus, and Turbo LSPs
Modern Tooling: Formatter, linter, and intelligent code completion for the view layer
Reactive Templates: Server-side templates with LiveView-inspired reactivity without abandoning .html.erb
Universal Templates: How server templates could potentially work client-side through transpilation

Highlights

Technical Breakthroughs: How advanced parsing enables next-generation view tooling
Prototype Demos: Early demonstrations of the enhanced developer experience
Architecture Options: Approaches for reactivity while maintaining Rails' server-centric philosophy
Community Roadmap: Steps needed to bring these ideas to a production-ready HTML rendering engine

Event: https://lu.ma/8jcbnfls

Transcript

1. The Modern View Layer Rails Deserves: A Vision for 2025 and Beyond Marco Roth July 22, 2025 - SF Bay Area Ruby Meetup
2. Marco Roth !  @marcoroth_  @marcoroth@ruby.social 🌐 marcoroth.dev  @marcoroth Full-Stack Developer & Open Source Contributor  @marcoroth.dev
3. I ❤ Open Source
4. CableReady Core Team Maintainer
5. The Rails View Layer
6. Action View
7. July 2004 - Rails 0.5.0 https://rubytalk.org/t/ann-rails-0-5-0-the-end-of-vaporware/12744
8. Rails is a open source web-application framework for Ruby. It ships with an answer for every letter in MVC: Action Pack for the Controller and View, Active Record for the Model.
9. ERB
10. Embedded Ruby
11. "So basically the templates are plain text files that can hold anything (HTML, XML, LaTeX, emails) sprinkled with Ruby embeddings to add dynamic behavior."
12. 2005 - Rails 1.0 Layouts + Partials
13. 2007 - Rails 2.0 *.html.erb show.html.erb instead of show.rhtml
14. 2010 - Rails 3.0 Automatic HTML escaping no more <%= h ... %>
15. 2010 - Rails 3.0 ActionView::Template unified interface for different handlers (ERB, Builder, etc.)
16. 2014 - Rails 4.1 Action View Variants actionview is extracted as it's own gem
17. 2017 - Rails 5.1 form_with
18. 2020 - Rails 6.1 ActionView::Component
20. https://www.youtube.com/watch?v=y5Z5a6QdA-M
21. 2020 - Rails 6.1 render_in(context)
22. 2021 - Rails 7.0 Hotwire by default
23. 2023 - Rails 7.1 Partial Strict Locals
24. <%# locals: (message:) -%> <%= message %>
25. Action View has been really stable
26. Most features/changes were additive
27. Makes it easy to rely and build on
29. Rails always has been about server-side rendered HTML
30. Action View isn't going anywhere
31. ERB isn't going anywhere
32. It's as pure as it gets, no distractions.
33. <h1>All Posts</h1> <ul> <% @posts.each do |post| %> <li> <%= link_to post.title, post_path(post) %> </li> <% end %> </ul>
34. Advanced HTML tooling is only getting more important
36. https://railsdeveloper.com/survey/2024/
37. https://railsdeveloper.com/survey/2024/
38. We are seeing more frameworks going back to simplicity
39. https://2024.stateofjs.com/en-US/libraries/front-end-frameworks/
40. https://2024.stateofjs.com/en-US/libraries/front-end-frameworks/
41. https://2024.stateofjs.com/en-US/libraries/front-end-frameworks/
42. Server-side rendered HTML
43. HTML Templating
44. But it's not without it's issues
45. Encapsulation View Boundaries Reusability Performance Tooling Testing Frontend Logic/Complexity
46. The Modern View Layer Rails Deserves: A Vision for 2025 and Beyond Marco Roth July 22, 2025 - SF Bay Area Ruby Meetup
47. Developer Tooling
49. https://x.com/jarredsumner/status/1635900145001971712
52. https://x.com/tenderlove/status/1575270860709302272
53. The JavaScript tooling and DX is awesome
56. Vite shows how a very well integrated tooling workflow looks like
58. It's a very coherent and awesome experience, all the way through
59. People expect good tooling nowadays
60. I believe that every new programming language needs to have that in mind.
62. It's something we can take inspiration and learn from.
63. I don't give a lot of credit to the JavaScript ecosystems
64. But I think that they nailed the view layer, components, DX, and the tooling aspects.
65. The whole Rails and greater Ruby ecosystem always worked seamlessly together too
66. A lot of gems are compatible, plug & play, and just work.
67. I think Rails is in a very good spot to adopt a coherent and seamless view layer.
68. or pretty much any other editor
69. 📄 *.js *.ts *.jsx *.tsx 📄 📄 📄
70. Instant Feedback Diagnostics Language Tools
71. Great out of the box experience
72. It just works.
73. How does that compare to Ruby?
74. In the last decade the experience for *.rb files were mixed
75. 2022 Ruby LSP
77. 1-click installation
78. ... and you get a great experience.
79. What about *.html.erb files?
80. It's still a different story
81. Hotwire + View Tooling
82. 2023 Stimulus LSP
83. 2024 Turbo LSP
86. No ERB support
87. HTML-only
88. For Rails apps it's quite common to use ActionView ERB helpers
89. <div data-controller="hello"> <input data-hello-target="name" type="text"> <button data-action="click->hello#greet"> Greet </button> <span data-hello-target="output"></span> </div>
90. <%= tag.div data: { controller: "hello" } do %> <%= content_tag :input, data: { hello_target: "name"} %> <%= button_tag data: { action: "click->hello#greet" } do %> Greet <% end %> <%= tag.span data: { hello_target: "output" } %> <% end %>
91. No tooling support
92. ActionView hasn't seen a lot of (developer) tooling
93. Me working on these tools gave me insights
94. I wanted to tackle the bigger picture
101. HTML-aware ERB Parser https://www.youtube.com/watch?v=EIoGfMGsiZI
102. HTML-aware ERB Parser HTML-aware ERB parser Written in C99 Built on Prism Designed for tooling Support for Action View Helpers
103. HTML-aware ERB Parser An interleaved Syntax Tree of HTML and Embedded Ruby
104. HTML-aware ERB Parser Structural Awareness of HTML+ERB files
105. Why not use Nokogiri + Prism?
106. <div> <span><%= @user.firstname %></span> <b><%= @user.lastname %></b> </div> <div> <span><%= @user.firstname %></span> <b><%= @user.lastname %></b> </div>
107. Ruby HTML <div> <span><%= @user.firstname %></span> <b><%= @user.lastname %></b> </div> <div> <span><%= @user.firstname %></span> <b><%= @user.lastname %></b> </div>
108. Ruby HTML <div> <span><%= @user.firstname %></span> <b><%= @user.lastname %></b> </div> <div> <span><%= @user.firstname %></span> <b><%= @user.lastname %></b> </div>
109. Ruby HTML @user.firstname @user.lastname <div> <span> </span> <b> </b> </div>
110. Ruby HTML @user.firstname @user.lastname <div> <span> </span> <b> </b> </div> t require "prism" Prism.parse("...") require "nokogiri" Nokogiri::HTML5.fragment("...")
111. Ruby HTML @user.firstname @user.lastname <div> <span> </span> <b> </b> </div> t
112. We lost the HTML-context in the process
113. We would need to piece the two parse results together
114. Which doesn't allow for much control with edge cases
115. <% if valid? %> <h1>Title</h1> <% end %>
116. <% if valid? %> <h1>Title</h1> <% end %> <% if valid? %> <h1>Title</h1> <% end %>
117. <% if valid? %> <h1>Title</h1> <% end %>
118. <% if valid? %> <h1>Title</h1> <% end %> @ ERBIfNode ├── tag_opening: "<%" ├── content: " if valid? " ├── tag_closing: "%>" ├── statements: │ └── @ HTMLElementNode │ ├── open_tag: │ │ └── @ HTMLOpenTagNode │ │ ├── tag_opening: "<" │ │ ├── tag_name: "h1" │ │ ├── tag_closing: ">" │ │ ├── children: [] │ │ └── is_void: false │ │ │ ├── tag_name: "h1" │ ├── body: │ │ └── @ HTMLTextNode │ │ └── content: "Title" │ │ │ └── close_tag: │ └── @ HTMLCloseTagNode │ ├── tag_opening: "</" │ ├── tag_name: "h1" │ └── tag_closing: ">" │ ├── subsequent: ∅ └── end_node: └── @ ERBEndNode ├── tag_opening: "<%" ├── content: " end " └── tag_closing: "%>"
119. <% if valid? %> <h1>Title</h1> <% end %> @ ERBIfNode ├── tag_opening: "<%" ├── content: " if valid? " ├── tag_closing: "%>" ├── statements: │ └── @ HTMLElementNode │ ├── open_tag: │ │ └── @ HTMLOpenTagNode │ │ ├── tag_opening: "<" │ │ ├── tag_name: "h1" │ │ ├── tag_closing: ">" │ │ ├── children: [] │ │ └── is_void: false │ │ │ ├── tag_name: "h1" │ ├── body: │ │ └── @ HTMLTextNode │ │ └── content: "Title" │ │ │ └── close_tag: │ └── @ HTMLCloseTagNode │ ├── tag_opening: "</" │ ├── tag_name: "h1" │ └── tag_closing: ">" │ ├── subsequent: ∅ └── end_node: └── @ ERBEndNode ├── tag_opening: "<%" ├── content: " end " └── tag_closing: "%>"
120. <% if valid? %> <h1>Title</h1> <% end %> @ ERBIfNode ├── tag_opening: "<%" ├── content: " if valid? " ├── tag_closing: "%>" ├── statements: │ └── @ HTMLElementNode │ ├── open_tag: │ │ └── @ HTMLOpenTagNode │ │ ├── tag_opening: "<" │ │ ├── tag_name: "h1" │ │ ├── tag_closing: ">" │ │ ├── children: [] │ │ └── is_void: false │ │ │ ├── tag_name: "h1" │ ├── body: │ │ └── @ HTMLTextNode │ │ └── content: "Title" │ │ │ └── close_tag: │ └── @ HTMLCloseTagNode │ ├── tag_opening: "</" │ ├── tag_name: "h1" │ └── tag_closing: ">" │ ├── subsequent: ∅ └── end_node: └── @ ERBEndNode ├── tag_opening: "<%" ├── content: " end " └── tag_closing: "%>"
121. <% if valid? %> <h1>Title</h1> <% end %> @ ERBIfNode ├── tag_opening: "<%" ├── content: " if valid? " ├── tag_closing: "%>" ├── statements: │ └── @ HTMLElementNode │ ├── open_tag: │ │ └── @ HTMLOpenTagNode │ │ ├── tag_opening: "<" │ │ ├── tag_name: "h1" │ │ ├── tag_closing: ">" │ │ ├── children: [] │ │ └── is_void: false │ │ │ ├── tag_name: "h1" │ ├── body: │ │ └── @ HTMLTextNode │ │ └── content: "Title" │ │ │ └── close_tag: │ └── @ HTMLCloseTagNode │ ├── tag_opening: "</" │ ├── tag_name: "h1" │ └── tag_closing: ">" │ ├── subsequent: ∅ └── end_node: └── @ ERBEndNode ├── tag_opening: "<%" ├── content: " end " └── tag_closing: "%>"
122. <% if valid? %> <h1>Title</h1> <% end %> @ ERBIfNode ├── tag_opening: "<%" ├── content: " if valid? " ├── tag_closing: "%>" ├── statements: │ └── @ HTMLElementNode │ ├── open_tag: │ │ └── @ HTMLOpenTagNode │ │ ├── tag_opening: "<" │ │ ├── tag_name: "h1" │ │ ├── tag_closing: ">" │ │ ├── children: [] │ │ └── is_void: false │ │ │ ├── tag_name: "h1" │ ├── body: │ │ └── @ HTMLTextNode │ │ └── content: "Title" │ │ │ └── close_tag: │ └── @ HTMLCloseTagNode │ ├── tag_opening: "</" │ ├── tag_name: "h1" │ └── tag_closing: ">" │ ├── subsequent: ∅ └── end_node: └── @ ERBEndNode ├── tag_opening: "<%" ├── content: " end " └── tag_closing: "%>"
123. <% if valid? %> <h1>Title</h1> <% end %> @ ERBIfNode ├── tag_opening: "<%" ├── content: " if valid? " ├── tag_closing: "%>" ├── statements: │ └── @ HTMLElementNode │ ├── open_tag: │ │ └── @ HTMLOpenTagNode │ │ ├── tag_opening: "<" │ │ ├── tag_name: "h1" │ │ ├── tag_closing: ">" │ │ ├── children: [] │ │ └── is_void: false │ │ │ ├── tag_name: "h1" │ ├── body: │ │ └── @ HTMLTextNode │ │ └── content: "Title" │ │ │ └── close_tag: │ └── @ HTMLCloseTagNode │ ├── tag_opening: "</" │ ├── tag_name: "h1" │ └── tag_closing: ">" │ ├── subsequent: ∅ └── end_node: └── @ ERBEndNode ├── tag_opening: "<%" ├── content: " end " └── tag_closing: "%>"
124. Ruby HTML @user.firstname @user.lastname <div> <span> </span> <b> </b> </div>
125. This opens a lot of doors for understanding, analyzing, working with HTML+ERB documents.
126. Preview Herb Formatter
127. HTML+ERB Auto-Formatter
128. <div><h1><%=@title%></h1><%if user_signed_in?%> <p>Welcome,<%= current_user.name%>!</p><%else%> <p>Please<%= link_to"sign in",login_path%>.</ p><%end%></div>
129. <div><h1><%=@title%></h1><%if user_signed_in?%> <p>Welcome,<%= current_user.name%>!</p><%else%> <p>Please<%= link_to"sign in",login_path%>.</ p><%end%></div> S cmd
130. <div><h1><%=@title%></h1><%if user_signed_in?%> <p>Welcome,<%= current_user.name%>!</p><%else%> <p>Please<%= link_to"sign in",login_path%>.</ p><%end%></div> bundle exec herb format [file]
131. <div> <h1><%= @title %></h1> <% if user_signed_in? %> <p>Welcome, <%= current_user.name %>!</p> <% else %> <p>Please <%= link_to "sign in", login_path %></p> <% end %> </div>
132. So that you could integrate it into your editor or CI workflow
135. Herb Linter
137. No style guide on how to write to good views
138. A way to help guide people towards best practices and to avoid commons mistakes
140. Accessibility rules (a11y)
142. A lot of them are semantic but we also have stylistic rules
148. Please open an issue if you have an idea for a new rule.
153. Herb Highlighter
155. Herb Rewriter Preview
156. Refactoring Tag Names <span> → <div> Refactoring Attribute Names data-example-target → data-hello-target Refactoring Attribute Values bg-blue-500 → bg-red-500
158. <%= tag.div class: "px-4 py-2 text-white bg-sky-700" %> <div class="px-4 py-2 text-white bg-sky-700"></div>
159. This gives us confidence to reliably refactor views
160. Herb Printer
161. <input required />
163. <input required />
164. Useful for auto-correcting lint issues
165. Herb Language Server
179. Unused Views/Partials detection
180. Jump to Definition for render calls
181. Herb Language Service
183. https://github.com/marcoroth/stimulus-lsp/pull/601
186. Release Herb v0.4.0
187. Herb Linter Herb Formatter (Preview) Improved VS Code Extension Improved Language Server Bug Fixes
188. The Modern View Layer Rails Deserves: A Vision for 2025 and Beyond Marco Roth July 22, 2025 - SF Bay Area Ruby Meetup
189. Vision ERB Rendering Engine
190. IMPORTANT
191. This is a vision.
192. New advancements require exploration.
193. Even if none of this is viable in production it's still worth exploring.
194. So here we go.
195. Vision ERB Rendering Engine
196. String Template Engine
197. HTML Templating Engine
198. An engine that cannot produce invalid HTML
202. .ex Elixir .rb Ruby
203. .eex Embedded Elixir(EEx) .erb Embedded Ruby(ERB) .ex Elixir .rb Ruby
204. .heex HTML+EEx (HEEx) .eex Embedded Elixir(EEx) .erb Embedded Ruby(ERB) .ex Elixir .rb Ruby
205. .heex HTML+EEx (HEEx) .eex Embedded Elixir(EEx) .erb Embedded Ruby(ERB) .ex Elixir .rb Ruby ?
206. .heex HTML+EEx (HEEx) .eex Embedded Elixir(EEx) .erb Embedded Ruby(ERB) .herb HTML+ERB (Herb) .ex Elixir .rb Ruby
207. .erb Embedded Ruby(ERB)
208. <h1>Hello, <%= name %>!
209. template = ActionView::Template.new( "<h1>Hello, <%= name %>!", "test.html.erb", ActionView::Template::Handlers::ERB, locals: [:name] ) <h1>Hello, <%= name %>!
210. template = ActionView::Template.new( "<h1>Hello, <%= name %>!", "test.html.erb", ActionView::Template::Handlers::ERB, locals: [:name] ) compiled = template.handler.call( template, template.source ) <h1>Hello, <%= name %>!
211. "@output_buffer.safe_append='<h1>Hello, '.freeze; @output_buffer.append=( name ); @output_buffer.safe_append='!'.freeze; \n@output_buffer" compiled = template.handler.call( template, template.source )
212. .herb HTML+ERB (Herb)
213. <h1>Hello, <%= name %>!
214. template = ActionView::Template.new( "<h1>Hello, <%= name %>!", "test.html.herb", ActionView::Template::Handlers::Herb, locals: [:name] ) compiled = template.handler.call( template, template.source )
215. compiled = template.handler.call( template, template.source )
216. compiled = template.handler.call( template, template.source ) # Tag `<h1>` opened at (1:1) was never closed before the end of document. UnclosedElementError in users/index.html.herb
217. Vision Reactive Templates
218. Phoenix LiveView HEEx-like
219. <ul> <% @items.each do |item| %> <li><%= item %></li> <% end %> </ul> View Template
220. @items = [1, 2, 3] <ul> <li>1</li> <li>2</li> <li>3</li> </ul> State View Template Rendered View Log Initial view rendered <ul> <% @items.each do |item| %> <li><%= item %></li> <% end %> </ul>
221. @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 <ul> <% @items.each do |item| %> <li><%= item %></li> <% end %> </ul>
222. @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 <ul> <% @items.each do |item| %> <li><%= item %></li> <% end %> </ul>
223. <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`
224. <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>
225. <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>
226. @items = [1, 2, 3, 4] 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> <ul> <% @items.each do |item| %> <li><%= item %></li> <% end %> </ul> <ul> <li>1</li> <li>2</li> <li>3</li> </ul>
227. @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 <ul> <% @items.each do |item| %> <li><%= item %></li> <% end %> </ul>
228. ERB is here to stay.
229. Action View is here to stay.
230. We want to level up Action View while keeping it Railsy.
232. What HEEx is for Phoenix LiveView Herb could be for Rails ReactionView
233. Level 1 - Better Feedback
237. Level 2 - HTML-aware Engine
238. String Template Engine
239. HTML Templating Engine
240. Backwards compatibility
241. compiled = template.handler.call( template, template.source ) # Tag `<h1>` opened at (1:1) was never closed before the end of document. UnclosedElementError in users/index.html.herb
242. Check for invalid syntax Check for valid HTML5 A11y Checks- Missing alt attributes on <img> XSS Checks - No unsafe interpolation Only one element with the same ID
244. Level 3 - Action View Optimizations
245. Compiling Templates
248. Inlining Partial Render Calls
249. Probably more
250. Level 4 - Reactive ERB Views
251. @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 <ul> <% @items.each do |item| %> <li><%= item %></li> <% end %> </ul>
252. index.html.erb
253. index.html
254. index.html .herb
255. Opt-in to new, stricter engine
256. Progressive Enhancements
257. Gradual Adoption
258. Not "All or nothing"
259. Only use it where it needed
260. index.html .erb .herb index.html ↓
261. Technically also allows for new syntax to be introduced
263. <NameComponent first-name="Rails" last-name="Conf" /> class NameComponent < ApplicationComponent def initialize(first_name:, last_name:) @first_name = first_name @last_name = last_name end end
264. Level 5 - Client-side Templates
266. Limited Set of ERB
267. RSC - React Server Components
268. "ERB Client Components"
269. Web Components React Components ...
270. Optimistic UI updates
271. Improved Offline Functionality (+ service workers)
272. Client-side rendering for non- critical and trivial interactions
273. Level 6 - External Components
274. When you need more and don't want to abandon HTML+ERB alltogether
275. Only on certain pages
277. pin "@rails/actioncable", to: "actioncable.esm.js" pin "@rails/activestorage", to: "activestorage.esm.js" pin "@rails/actiontext", to: "actiontext.esm.js" pin "trix" pin_all_from "controllers" importmap-rails
278. Register external components import [:Alert, :AlertTitle], from: "shadcn" import_all_from "app/javascript/components" config/initializers/reactionview.rb
279. <h1><%= @post.title %></h1> <Alert variant="default"> <AlertTitle>Heads up!</AlertTitle> </Alert> app/views/posts/show.html.herb
280. The engine knows that these components are client-side and knows how to mount/ hydrate them
282. Tightly integrated Built-in Tooling No setup Works out of the box
283. I want to see what's possible
284. Vision What's next
285. Formatter Linter/Formatter Configuration ReactionView
287. Conclusion
288. Prism had a big effect on Ruby internals and the tooling landscape
289. Herb could have a similar effect for HTML Templating and Tooling
290. The community has built incredible tooling for Ruby itself.
291. Now it's time to bring that same care to the view layer.
292. With Herb, I believe we have a path to level up the view layer
294. I want to keep Ruby as attractive and as possible
297. herb-tools.dev
299. cd your_project/ gem install herb herb analyze .
301. Thank you $  @marcoroth_  @marcoroth@ruby.social 🌐 marcoroth.dev  @marcoroth  @marcoroth.dev  /in/marco-roth