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

Tired of wrestling with complex templating in your Go web projects? Discover Mold, a lightweight yet powerful template engine designed to streamline your workflow and boost your productivity. Mold builds on the familiar foundation of Go templates, adding structure and clarity for building maintainable web applications.

Why Choose Mold for Your Go Projects?

Mold offers a compelling blend of simplicity and functionality. Here are the key features that make it an ideal choice:

Lightweight: Zero external dependencies mean faster build times and reduced project bloat.
Efficient: Under the hood, Mold leverages Go's built-in template parser for optimal performance.
Capable: Supports the full power of Go templates, giving you complete control over your output.
Familiar: Employs well-known concepts like Layouts, Views, and Partials for intuitive organization.

Get Started with Mold in Minutes

Integrating Mold into your project is straightforward. Here's a quick example:

Create a View File: Design your HTML content using standard Go templates.

{{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 Template: Instantiate Mold and use it to render your view within an 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)
}

Mastering Key Concepts of Go Templating with Mold

Mold brings order to your Go templates through three core concepts: Layouts, Views, and Partials. The combination helps create very efficient go templates.

Layouts: The Foundation of Your Web Pages

Define the overall structure of your web pages (headers, footers, navigation).
Use {{render}} to inject the view's content into the layout's body.
Render named sections (e.g., {{render "head"}}) to insert content into specific areas.

Customize the default layout by specifying a custom layout file during instantiation.

option := mold.WithLayout("path/to/layout.html")
engine, err := mold.New(fs, option)

Views: The Content Specific to Each Page

Views are HTML templates that hold page-specific content.
They are rendered within the body of a layout using the engine.Render function.
Think of a view as everything that populates the <body> of an HTML page.
```
engine.Render(w, "path/to/view.html", nil)
```

Partials: Reusable Template Snippets

Break down complex views into smaller, reusable components.
Use the {{partial "path/to/partial.html"}} function to include partials in both Views and Layouts.
Pass custom data to partials for dynamic content generation.

Sections: Targeted Content Injection

Sections allow you to render specific content blocks in designated areas of your layout. Sections enable a lot of flexibilty when working with go templates.

Define sections within views using {{define "sectionName"}} ... {{end}}.
Render sections in your layout using {{render "sectionName"}}.

The default head section helps with HTML content injection.

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

Mold vs. Standard Go Templates: Why the Upgrade?

While Go templates are simple and powerful, managing numerous template files can become cumbersome. Mold offers an intuitive structure for organizing your Go templates, making web application development more efficient and enjoyable. Mold helps improve the use of go web frameworks.

Ready to simplify your Go web development? Give Mold a try and experience the power of structured templating. Looking for more? Check out the official Go package documentation.