588 GitHub stars and counting — benbjohnson/ego is a Go project TopGit is tracking across repositories on the platform. An ERB-style templating language for Go.
Snapshot summary built from the project's own GitHub metadata — there's no written TopGit review yet. The page will update automatically when a full review is published.
WHY NO REVIEW YET
TopGit writes full reviews for the most-starred, most-requested repositories. This page is a snapshot until then — see the READ ME tab for the original README in full.
Ego is an ERb style templating language for Go. It works by transpiling templates into pure Go and including them at compile time. These templates are light wrappers around the Go language itself.
Install
You can find a release build of ego for Linux on the Releases page.
To install ego from source, you can run this command outside of the GOPATH:
$ go get github.com/benbjohnson/ego/...
Usage
Run ego on a directory. Recursively traverse the directory structure and generate Go files for all matching .ego files.
$ ego mypkg
How to Write Templates
An ego template lets you write text that you want to print out but gives you some handy tags to let you inject actual Go code.
This means you don't need to learn a new scripting language to write ego templates—you already know Go!
Raw Text
Any text the ego tool encounters that is not wrapped in <% and %> tags is considered raw text.
If you have a template like this:
hello!
goodbye!
Then ego will generate a matching .ego.go file:
io.WriteString(w, "hello!\ngoodbye!")
Unfortunately that file won't run because we're missing a package line at the top.
We can fix that with code blocks.
Code Blocks
A code block is a section of your template wrapped in <% and %> tags.
It is raw Go code that will be inserted into our generate .ego.go file as-is.
Note the context and io packages are automatically imported to your template.These are the only packages that do this.You'll need to import any other packages you use.
Print Blocks
Our template is getting more useful.
We now have actually runnable Go code.
However, our templates typically need output text frequently so there are blocks specifically for this task called print blocks.
These print blocks wrap a Go expression with <%= and %> tags.
We can expand our previous example and add a type and fields to our code:
The <%= %> block will print your text as escaped HTML, however, sometimes you need the raw text such as when you're writing JSON.
To do this, simply wrap your Go expression with <%== and %> tags.
Components
Simple code and print tags work well for simple templates but it can be difficult to make reusable functionality.
You can use the component syntax to print types that implement this Renderer interface:
type Renderer interface {
Render(context.Context, io.Writer)
}
Component syntax look likes HTML.
You specify the type you want to instantiate as the node name and then use attributes to assign values to fields.
The body of your component will be assigned as a closure to a field called Yield on your component type.
For example, let's say you want to make a reusable button that outputs Bootstrap 4.0 code:
We can write this component as an ego template or in pure Go code.
Here we'll write the component in Go:
The Yield is a special instance of a closure, however, you can also specify named closures using the :: syntax.
Given a component type:
type MyView struct {
Header func()
Yield func()
}
We can specify the separate closures like this:
<ego:MyView>
<ego::Header>
This content will go in the Header closure.
</ego::Header>
This content will go in the Yield closure.
</ego:MyView>
Importing components from other packages
You can import components from other packages by using a namespace that matches the package name
The ego namespace is reserved to import types in the current package.
For example, you can import components from a library such as bootstrap-ego:
The most recent commit recorded on benbjohnson/ego was 3.7 years ago, based on the GitHub push timestamp. The repository has 39 forks — one of the better signals of community interest.
How does benbjohnson/ego compare to other Backend projects?
benbjohnson/ego is tracked by TopGit in the Backend category, with 588 GitHub stars and written in Go. Browse the Backend topic page on TopGit to compare it against similar projects by stars and activity.
How many stars does benbjohnson/ego have?
benbjohnson/ego has 588 GitHub stars — refresh the page for the live number, or check github.com/benbjohnson/ego. TopGit mirrors GitHub's count but does not claim minute-by-minute accuracy.
What is benbjohnson/ego?
benbjohnson/ego (benbjohnson/ego) is a Go project on GitHub. From the project's own README: An ERB-style templating language for Go.
What language is benbjohnson/ego written in?
benbjohnson/ego is written primarily in Go. GitHub's language field is based on the largest share of bytes in the default branch.
What topics is benbjohnson/ego associated with?
GitHub's repository topics for benbjohnson/ego: "erb", "go", "template-language". TopGit's editorial category is Backend.
Why is benbjohnson/ego categorized under Backend?
TopGit places benbjohnson/ego in the Backend category based on its GitHub topics and description (tagged: "erb", "go", "template-language"). Categories are assigned from real repository metadata, not editorial guesswork.
Read full README in the tab above.
Want a second opinion on ego?
Ask an AI that can read this page — one click and you get its take on ego.