Supercharge Your Go Web Apps with Mold: The Intuitive Templating Engine

Tired of wrestling with complex templating in your Go projects? Discover Mold, a lightweight, efficient, and familiar templating engine built on Go's standard library. Learn how Mold simplifies web development by providing an intuitive structure for your layouts, views, and partials.

Why Choose Mold for Go Templating?

Mold gives you a better way to manage Go templates while boosting developer productivity. Here’s what makes Mold stand out:

Lightweight: No external dependencies. Mold leverages the power of Go's standard library, keeping your project lean.
Efficient: Mold harnesses Go's in-built template parser under the hood.
Capable: Supports all the features of Go templates.
Familiar: Uses layouts, views, and partials to better organize the templating process.

Getting Started with Mold: A Quick Example

Ready to see Mold in action? Here's how to render a simple view:

Create a View File: Name it index.html. This file includes simple HTML content that you'd like to render.

{{define "head"}}
<link rel="stylesheet" href="https://cdn.simplecss.org/simple.min.css">
{{end}}
<h1>Hello from a <a href="//github.com/abiosoft/mold">Mold</a> template</h1>

Render the View: Use the following code in your HTTP handler:

//go:embed index.html
var dir embed.FS
var engine, _ = mold.New(dir)

func handle(w http.ResponseWriter, r *http.Request) {
    engine.Render(w, "index.html", nil)
}

Key Concepts: Mastering Mold's Architecture

Mold simplifies web development using three key concepts: layouts, views, and partials.

Layouts: Define Your Web Page Structure

Layouts provide the overall structure for your web pages. They define the common elements, like headers, footers, and navigation menus across all views.

Use {{render}} to insert the view's content into the layout's body.
Use {{render "sectionName"}} to render a specific section within the layout.

<!DOCTYPE html>
<html>
<head>
    {{render "head"}}
</head>
<body>
    {{render}}
</body>
</html>

Views: Craft Your Unique Content

Views are templates that generate the content inserted into the body of layouts. These are specific to a particular page.

Views typically contain the HTML content you'd normally find within the <body> tag.
Pass the view's path to the rendering engine to produce HTML output:
```
engine.Render(w, "path/to/view.html", nil)
```

Partials: Reusable Template Snippets

Partials are reusable template snippets that allow you to break down complex views into smaller, manageable components.

Use the {{partial "path/to/partial.html"}} function in both views and layouts.
Customize the data passed to the partial: {{partial "partials/user_session.html".User}}.

Sections: Injecting Content into Specific Layout Areas

Sections allow you to render content in specific areas of the layout like the <head>. This helps you manage things like CSS and JavaScript on a per-page basis.

Define sections within your views using the {{define "sectionName"}} block.

{{define "scripts"}}
<script src="//unpkg.com/alpinejs" defer></script>
{{end}}

Mold vs. Standard Go Templates: Why Make the Switch?

While Go templates are powerful, managing multiple files can become unwieldy. Mold provides an intuitive framework for structuring web applications with Go templates. This makes it easier to create maintainable and scalable web applications.

Mold makes organizing the templating process easier using a familiar structure of layouts, views, and partials. With Mold, your Go web development becomes more streamlined and efficient.