How do you embed static assets into a Go binary?
Aug 01, 2025 am 05:41 AMUse Go's embed package to embed static resources into binary files. 1. Use the //go:embed directive and embed package to embed files or directories into variables; 2. It can be embedded in string, []byte, or embed.FS types; 3. The file path is relative to the directory where the Go source file is located; 4. Use assets/... to implement recursively embed subdirectories; 5. Access the embedded files through fs.ReadFile or http.FileServer. All resources are included at compile time and need to be recompiled. It is suitable for web applications or CLI tools without external dependencies.
You embed static assets into a Go binary using Go's built-in embed
package (available since Go 1.16). This allows you to include files like HTML templates, CSS, JavaScript, images, or config files directly in your compiled binary—no external dependencies needed.

Use the //go:embed
directive with the embed
package
The embed
directive works by annotating variables in your Go code. You import the "embed"
package and use the //go:embed
comment above a compatible variable to specify which files or directories to include.
Example: Embed a single file
package main import ( "embed" "fmt" "io/fs" ) //go:embed version.txt var version string func main() { fmt.Println("Version:", version) }
Here, version.txt
is read into the version
string at compile time.

Example: Embed multiple files or directories
package main import ( "embed" "net/http" ) //go:embed assets/* var assetFS embedded.FS //go:embed templates/*.html var templateFS embedded.FS func main() { mux := http.NewServeMux() mux.Handle("/static/", http.FileServer(http.FS(assetFS))) // You can also read files directly content, _ := templateFS.ReadFile("templates/index.html") _ = content // use it as needed }
In this case:
-
assets/*
include all files in theassets
directory. -
templates/*.html
include only.html
files. -
embed.FS
gives you a filesystem interface to access the embedded files.
Key points to remember
- File paths are relative to the package directory (where the
.go
file is). - You can embed into:
-
string
or[]byte
(for single files) -
embed.FS
(for one or more files/directories)
-
- The files are included at compile time , so any changes require recompilation.
- Directory patterns like
dir/*
do not recurse into subdirectories. Usedir/...
for recursive embedding:
//go:embed assets/... var assetFS embed.FS // include subdirectories
Accessing embedded files safely
Use fs.FS
helpers to avoid hardcoding paths and improve testability:

content, err := fs.ReadFile(templateFS, "templates/home.html") if err != nil { panic(err) }
Or serve via HTTP:
http.ListenAndServe(":8080", http.FileServer(http.FS(assetFS)))
Summary
- Use
//go:embed
withembed.FS
,string
, or[]byte
. - Paths are relative to the Go source file.
- Use
assets/...
for recursive inclusion. - Works great for web apps, CLI tools, or anything needing bundled resources.
Basically, it's clean, standard, and no third-party tools needed. Just write the directive and go.
The above is the detailed content of How do you embed static assets into a Go binary?. For more information, please follow other related articles on the PHP Chinese website!

Hot AI Tools

Undress AI Tool
Undress images for free

Undresser.AI Undress
AI-powered app for creating realistic nude photos

AI Clothes Remover
Online AI tool for removing clothes from photos.

Clothoff.io
AI clothes remover

Video Face Swap
Swap faces in any video effortlessly with our completely free AI face swap tool!

Hot Article

Hot Tools

Notepad++7.3.1
Easy-to-use and free code editor

SublimeText3 Chinese version
Chinese version, very easy to use

Zend Studio 13.0.1
Powerful PHP integrated development environment

Dreamweaver CS6
Visual web development tools

SublimeText3 Mac version
God-level code editing software (SublimeText3)

Hot Topics

Go's template engine provides powerful dynamic content generation capabilities through text/template and html/template packages, where html/template has automatic escape function to prevent XSS attacks, so it should be used first when generating HTML. 1. Use {{}} syntax to insert variables, conditional judgments and loops, such as {{.FieldName}} to access structure fields, {{if}} and {{range}} to implement logical control. 2. The template supports Go data structures such as struct, slice and map, and the dot in the range represents the current iterative element. 3. The named template can be defined through define and reused with the template directive. 4.ht

Go and Kafka integration is an effective solution to build high-performance real-time data systems. The appropriate client library should be selected according to needs: 1. Priority is given to kafka-go to obtain simple Go-style APIs and good context support, suitable for rapid development; 2. Select Sarama when fine control or advanced functions are required; 3. When implementing producers, you need to configure the correct Broker address, theme and load balancing strategy, and manage timeouts and closings through context; 4. Consumers should use consumer groups to achieve scalability and fault tolerance, automatically submit offsets and use concurrent processing reasonably; 5. Use JSON, Avro or Protobuf for serialization, and it is recommended to combine SchemaRegistr

When passing slices in Go, it is usually passed directly by value, because the slice header contains a pointer to the underlying array, and copying the slice header will not copy the underlying data, so the modification of elements in the function will affect the original slice; 1. If you need to reassign or adjust the slice length within the function and make the change take effect, you should pass the slice pointer; 2. Otherwise, you can pass the slice directly without using a pointer; 3. If reallocation may be triggered when using append, you must pass through the pointer to make the updated slice visible to the outside. Therefore, unless the entire slice is to be replaced, the slice should be passed in the form of a value.

govetcatchescommonlogicalerrorsandsuspiciousconstructsinGocodesuchas1)misuseofprintf-stylefunctionswithincorrectarguments,2)unkeyedstructliteralsthatmayleadtoincorrectfieldassignments,3)sendingtoclosedchannelswhichcausespanics,4)ineffectiveassignment

Use signal.Notify() in the os/signal package to register the specified signal (such as SIGINT, SIGTERM) into the buffer channel, so that the program can be captured instead of terminated by default; 2.

Usereflect.ValueOfandreflect.TypeOftogetruntimevaluesandtypes;2.Inspecttypedetailswithreflect.TypemethodslikeName()andKind();3.Modifyvaluesviareflect.Value.Elem()andCanSet()afterpassingapointer;4.CallmethodsdynamicallyusingMethodByName()andCall();5.R

To embed the file contents into the string of the Go program, you should use go:embed (Go1.16) to embed the file at compile time; 1. Add the //go:embed directive above the target variable; 2. Ensure the file path is correct and the file exists; 3. Use string type variables to receive text content; 4. Build the project through gobuild to include the file content. This method is safe and efficient and does not require additional tools, and ultimately implements the file contents directly into the binary file as strings.

In Go language, HTTP middleware is implemented through functions, and its core answer is: the middleware is a function that receives and returns http.Handler, used to execute general logic before and after request processing. 1. The middleware function signature is like func (Middleware(nexthttp.Handler)http.Handler), which achieves functional expansion by wrapping the original processor; 2. The log middleware in the example records the request method, path, client address and processing time-consuming, which is convenient for monitoring and debugging; 3. The authentication middleware checks the Authorization header, and returns 401 or 403 errors when verification fails to ensure secure access; 4. Multiple middleware can be nested to adjust
