quicktemplate VS pongo2

Here are a couple:

https://github.com/julvo/htmlgo

https://github.com/rohanthewiz/element

I'm sure there are many more.

The thing about these is that performance is often not as good as when using templates, especially when the templates are compiled to native code. Quicktemplate [1] is still the leader here IMO, and I don't think the OP project brings much that couldn't be done pretty easily with QT.

[1] https://github.com/valyala/quicktemplate

From my experience you don't really need a distinct frontend framework for web development in Go. I've been able to use quicktemplate for some of my projects for rendering HTML pretty effectively. I've written about using it here.

If the question is about templating libraries, then I've seen people use other libraries than the html/template, like https://github.com/hoisie/mustache or https://github.com/valyala/quicktemplate

I originally started out trying to add features to quicktemplate, but didn't get any engagement, so went my own way: https://github.com/valyala/quicktemplate/issues/80

I've been using quick template with htmx and I'm really enjoying the combo. As a mostly backend developer it's a pretty intuitive approach. Now if someone could just build something to simplify working with CSS...

Like with the previous post, we're going to use djinn-ci/imgsrv as an example of using multiple sources in a build manifest. If we look at the top of the manifest file, we will see that it requires three repositories to build. These are, the source code for djinn-ci/imgsrv itself, golang/tools, and valyala/quicktemplate, defined like so,

I like Hugo quite a lot, but I don't like Go's standard library templates. I wonder if it is possible to use https://github.com/valyala/quicktemplate with Hugo?

For encoding, the receivers usually want very specific encoding (namespaces, nil as xsi:nil, not omitted value...) - templating with text/template or github.com/valyala/quicktemplate is easier on the long run, than fight with xml.Marshal and the other end's unspoken assumptions.

The "Hello World" example is up at https://github.com/a-h/qt-lsp - it's called qt-lsp because I started down this track looking to build IDE support for quicktemplate - https://github.com/valyala/quicktemplate/issues/80 - but didn't think it was practical when I dug into the design of quicktemplate more.

I've used https://github.com/flosch/pongo2 since it feels more dev friendly (like almost every other framework I've used). Check out https://github.com/avelino/awesome-go#template-engines for some others.

Doesn’t it bother your that your templates aren’t really valid HTML? Because of the way html/template works, one isn’t really able to implement template inheritance properly. So you end up with opening and closing tags scattered around multiple files? You might want to look at Pongo2, which implements most of Django’s templating syntax (incl. inheritance) and is pretty stable: https://github.com/flosch/pongo2

At least template-wise, I've developed pongo2 mimicking Django's template engine which I use myself for various projects. For the rest I usually stick with the standard library (net/http), golang-jwt, the Gorilla toolkit (note that it's been archived recently) and some software architecture patterns for middlewares, database abstraction, etc.

pongo2 is a community-built template engine with syntax inspired by Django-syntax. It is built by the community for Go. It is very popular today, with more than 2K stars on GitHub.

Django uses Jinja templating engine. Something similar is available at https://github.com/flosch/pongo2 Now you just have to pick which router you want and which ORM or not-ORM.

Yes, Go templating is quite hard. There was a feature request[1] to implement the Django/Jinja2-like Pongo2 template engine[2], but got rejected because it would have been a too big change.

[1]: https://github.com/gohugoio/hugo/issues/1359

[2]: https://github.com/flosch/pongo2

Yes, there is pongo2 [0] and my runner (basically a small Go software that runs the template engine) pongo2-runner [1].

I'm not the author of the library (pongo2), but I'm using pongo2-runner to dynamically create config files out of environment variables, with custom logic. Super recommended.

[0]: https://github.com/flosch/pongo2

[1]: https://github.com/swisscom/pongo2-runner