Exploring Roq: Building High-Performance Static Sites with Quarkus

Roq is an innovative static site generator that brings the power of Quarkus and Java into the world of static web development. Created by Andy Damevin, a developer with nearly a decade of experience on the Quarkus team, Roq began as an experiment to determine whether a static site generator could be built on top of Quarkus. The result is a tool that offers impressive speed, reliability, and Java ecosystem integration, challenging the dominance of popular generators written in Go or JavaScript. Below, we answer key questions about Roq, its design decisions, migration process, and future roadmap.

• What is Roq and how did it start?
• Why did Andy Damevin choose Java and Quarkus for Roq?
• How can users migrate an existing static site to Roq?
• What are the key advantages of using Quarkus for static site generation?
• What is the future roadmap for Roq?
• How does Roq compare to other static site generators like Hugo or Jekyll?

What is Roq and how did it start?

Roq is a static site generator built entirely on the Quarkus framework, created by Andy Damevin, a long-time Quarkus contributor. It started as a side experiment to test if Java and Quarkus could efficiently generate static websites—something typically done with languages like Go or Ruby. The experiment proved successful, demonstrating that Quarkus’s fast startup, build-time processing, and low memory footprint could rival tools like Hugo. Roq processes Markdown, templates, and static assets to produce plain HTML, CSS, and JavaScript, making it suitable for blogs, documentation sites, or project landing pages. The project is open source and aims to bring Java developers into the static site ecosystem with familiar tooling.

Why did Andy Damevin choose Java and Quarkus for Roq?

Andy Damevin chose Java and Quarkus for Roq because of his deep expertise in Quarkus and desire to leverage its unique strengths. Quarkus provides near-instant startup times, minimal memory usage, and a compile-time oriented architecture that removes the traditional overhead of Java runtime. This makes it ideal for static site generation, where each build can be fully optimized ahead of time. Additionally, using Java opens up a vast ecosystem of libraries, tools, and developer talent. The choice also challenges the assumption that static site generators must be written in lightweight interpreted or Go languages. By using Quarkus, Roq can offer strong typing, rich templating, and seamless integration with Java build tools like Maven or Gradle, while still matching the performance of generators written in Go.

How can users migrate an existing static site to Roq?

Migrating to Roq involves restructuring your content into a format that Roq expects. The tool supports standard Markdown files with front matter, similar to Jekyll or Hugo. Users can copy their existing posts, pages, and assets into Roq’s directory structure, then create or adapt templates using Quarkus’s Qute templating engine. Andy Damevin recommends starting with a minimal Roq configuration and gradually moving content, testing builds with Roq’s development server. Roq also supports plugins and extensions, allowing users to replicate custom functionality from other generators. The migration guide on the official website provides step-by-step instructions for common scenarios, including handling pagination, tags, and permalinks. Since Roq uses standard formats, the process is straightforward for developers familiar with the static site ecosystem.

What are the key advantages of using Quarkus for static site generation?

Quarkus brings several key advantages to static site generation through Roq. First, build-time processing allows many tasks—such as template compilation, Markdown rendering, and resource optimization—to happen during the build phase, reducing runtime overhead. Second, fast startup and low memory make development iterations snappy, even on large sites. Third, Quarkus’s compiled ahead-of-time (AOT) capabilities generate native binaries that can run rapidly in CI/CD pipelines. Fourth, developers benefit from Java’s robustness, including strong typing, refactoring support in IDEs, and rich debugging tools. Fifth, Quarkus’s extension ecosystem integrates easily with databases, REST clients, and security frameworks, enabling hybrid static-dynamic features. Finally, performance is comparable to Go-based generators, fulfilling the “speed of Go” promise while staying in the Java ecosystem.

What is the future roadmap for Roq?

Andy Damevin envisions Roq evolving into a mature, general-purpose static site generator that competes directly with Hugo and Gatsby. Planned features include better support for internationalization, a richer theme marketplace, and an improved CLI with scaffolding commands. The team also wants to enhance the plugin API to allow community contributions for image optimization, sitemaps, and RSS feeds. Additionally, they are exploring deeper integration with Quarkus’s reactive capabilities for real-time previews and incremental builds. The long-term goal is to make Roq the go-to choice for Java developers who want a modern static site experience without leaving the JVM world. Contributions are welcome, and the project is actively seeking feedback from early adopters.

How does Roq compare to other static site generators like Hugo or Jekyll?

Roq differentiates itself by leveraging the Java and Quarkus stack, offering performance that matches Hugo’s Go-based engine while providing access to Java’s rich tooling. Compared to Jekyll (Ruby), Roq builds are typically faster and more memory-efficient. Unlike Hugo, which uses Go templates, Roq uses Qute, a type-safe, reactive templating engine that integrates tightly with Java. Roq also benefits from Quarkus’s hot reload capability, making development smoother than with many alternatives. However, it is newer than Hugo or Jekyll, so its community and theme library are smaller. For Java shops or developers already invested in the Quarkus ecosystem, Roq provides a natural choice that minimizes context switching. Its performance and extensibility make it a strong contender, especially for projects requiring Java-specific integrations.