Blogatto offers a comprehensive Gleam framework that transforms markdown content and Lustre views into fully static blogs, complete with RSS feeds, sitemaps, and multilingual support.
Building static blogs has traditionally required juggling multiple tools and configurations, but Blogatto reimagines this process by providing a unified Gleam framework that handles everything from markdown parsing to RSS feed generation. This comprehensive tool streamlines static site creation by integrating Lustre views, Maud components, and markdown processing into a cohesive build pipeline.
Core Architecture and Philosophy
At its foundation, Blogatto embraces the static site philosophy: pre-render everything at build time for maximum performance and security. The framework processes markdown files with YAML frontmatter, Lustre view functions for dynamic pages, and various XML formats for syndication and discovery. This approach eliminates runtime dependencies while maintaining flexibility through customizable components.
Content Management System
Blogatto's content model centers on markdown files with frontmatter, supporting both single-language and multilingual blogs. Writers can create posts in markdown format, adding YAML frontmatter for metadata like titles, dates, and tags. The multilingual system works elegantly—simply create language-specific files like index-it.md or index-fr.md alongside the default index.md, and Blogatto handles the routing automatically.
The framework parses these markdown files, extracts frontmatter, renders HTML content, and manages associated assets. This means images, scripts, or other resources referenced in posts get copied to the appropriate output locations, maintaining the integrity of your content structure.
Static Page Generation with Lustre
Where many static site generators struggle with dynamic content, Blogatto leverages Lustre's functional reactive programming model. Developers can map URL paths to Lustre view functions that receive the complete list of blog posts as context. This enables features like tag-based archives, category listings, or custom index pages that reactively update when content changes.
The separation between content (markdown) and presentation (Lustre views) follows established web development patterns while maintaining the static nature of the output. View functions can filter, sort, or transform post data before rendering, providing powerful customization without sacrificing performance.
Syndication and Discovery Features
Blogatto recognizes that modern blogs need more than just HTML pages. The framework generates RSS 2.0 feeds with configurable filtering and custom serialization options. This means you can create multiple feeds targeting different audiences—perhaps one for all posts, another filtered by category, or a custom feed with specific metadata formatting.
Automatic sitemap XML generation covers both static pages and blog posts, ensuring search engines can discover your entire site structure. The sitemap includes last modification dates and priority information, helping search engines understand your content hierarchy. Additionally, configurable robots.txt files with sitemap references provide granular control over crawler behavior and site policies.
Customization and Extensibility
Understanding that no two blogs are identical, Blogatto offers extensive customization options. Developers can override markdown element rendering through Maud components, allowing complete control over how headers, lists, code blocks, and other markdown features translate to HTML. This is particularly valuable for implementing custom styling or semantic HTML structures.
Blog post templates provide full control over page layout, enabling consistent branding and navigation across all content. The framework also supports custom markdown rendering, meaning you can transform specific markdown elements into complex HTML structures or even interactive components.
Build Process and Development Workflow
Blogatto's build pipeline follows a logical sequence: cleaning the output directory, copying static assets, generating configuration files, parsing and rendering content, and producing final output. This predictable process makes debugging straightforward and ensures reproducible builds.
The development experience includes file watching, auto-rebuild capabilities, and live reload functionality. These features create a smooth development workflow where changes to markdown files, Lustre views, or configuration immediately reflect in the development server without manual intervention.
Error Handling and Reliability
The framework includes comprehensive error handling patterns, distinguishing between recoverable and fatal errors. This means build failures provide clear diagnostics while allowing developers to handle common issues gracefully. The API documentation on HexDocs provides detailed information about error types and recovery strategies.
Deployment and Production Use
Since Blogatto generates purely static files, deployment is straightforward. The output directory contains everything needed for hosting on any static hosting provider—whether that's Netlify, Vercel, GitHub Pages, or a traditional web server. This simplicity eliminates the complexity of database management, server configuration, and runtime dependencies.
Technical Implementation Details
Under the hood, Blogatto uses Gleam's type system to ensure configuration correctness at compile time. The builder pattern for configuration provides a fluent API that guides developers through the setup process while preventing common configuration errors. Maud components handle HTML generation with type safety, reducing runtime errors and improving developer experience.
The framework's modular design means each component—markdown parsing, RSS generation, sitemap creation—can be used independently or replaced with custom implementations. This flexibility supports both simple blogs and complex, feature-rich sites without forcing a one-size-fits-all approach.
Getting Started and Community
Documentation includes a comprehensive guide covering installation, project setup, and building your first site. The example blog walkthrough demonstrates the complete workflow, while the API reference provides detailed information for advanced use cases. Community resources and examples help new users understand best practices and common patterns.
Blogatto represents a thoughtful approach to static site generation, combining the simplicity of markdown with the power of functional reactive programming. By handling the entire build process—from content parsing to final deployment—it allows developers to focus on creating great content rather than managing build tools and configurations. The framework's emphasis on type safety, customization, and developer experience makes it a compelling choice for anyone building static blogs with Gleam.
Comments
Please log in or register to join the discussion