O Fyne acaba de chegar à versão 2.8 com mais de mil commits, trazendo novos componentes de gráficos, APIs melhoradas e otimizações que tornam o desenvolvimento de aplicações desktop com Go ainda mais prático. Neste post, vamos explorar o que mudou e como você pode aproveitar essas novidades.

O que é Fyne?

Fyne é um framework Go para construir interfaces gráficas modernas que funcionam no Linux, macOS e Windows com o mesmo código. Diferente de outras abordagens que geram binários pesados, o Fyne oferece um controle fino sobre performance e tamanho de arquivo — ideial para apps desktop leves e responsivos.

Se você trabalha com Go e já se perguntou como fazer uma boa GUI sem mergulhar em C++, Fyne é a resposta.

Novidades da v2.8

Novos componentes de gráficos

A v2.8 introduziu um novo package canvas com suporte expandido para gráficos e renderização. Agora você pode criar visualizações mais elaboradas sem depender de bibliotecas externas complexas.

package main

import (
	"image/color"

	"fyne.io/fyne/v2/app"
	"fyne.io/fyne/v2/canvas"
	"fyne.io/fyne/v2/container"
)

func main() {
	a := app.New()
	w := a.NewWindow("Fyne v2.8")
	w.SetTitle("Fyne v2.8 Graphics")

	// Novo: suporte a gráficos vetoriais mais complexos
	circle := canvas.NewCircle(color.White)
	circle.StrokeColor = color.NRGBA{R: 255, A: 255}
	circle.StrokeWidth = 2

	w.SetContent(container.NewVBox(circle))
	w.ShowAndRun()
}

APIs refinadas

A API de bindings foi completamente reformulada na v2.8. Agora é bem mais intuitivo vincular dados com a UI — menos código boilerplate, mais clareza.

// Antes: muitas lines de binding manual
// Agora: direto e simples
type Person struct {
	Name string
	Age  int
}

person := Person{Name: "João", Age: 30}
nameBinding := binding.BindString(&person.Name)
nameEntry := widget.NewEntryWithData(nameBinding)

Melhorias de performance

O renderer foi otimizado significativamente. Aplicações Fyne agora usam menos CPU em repouso e scrolling é muito mais suave — uma vitória para quem trabalha com listas grandes.

Na prática: Um exemplo real

Vou mostrar uma aplicação simples que aproveita as novidades — um gerenciador de tarefas com visualização gráfica do progresso.

package main

import (
	"fyne.io/fyne/v2"
	"fyne.io/fyne/v2/app"
	"fyne.io/fyne/v2/container"
	"fyne.io/fyne/v2/widget"
)

func main() {
	a := app.New()
	w := a.NewWindow("task-manager")
	w.SetTitle("Task Manager - Fyne v2.8")

	// Título
	title := widget.NewLabel("Minhas Tarefas")

	// Lista de tarefas
	tasks := []string{"Implementar API", "Documentação", "Testes unitários"}
	taskList := widget.NewList(
		func() int { return len(tasks) },
		func() fyne.CanvasObject { return widget.NewLabel("") },
		func(id int, obj fyne.CanvasObject) {
			obj.(*widget.Label).SetText(tasks[id])
		},
	)

	// Barra de progresso visual (novo em v2.8)
	progressBar := widget.NewProgressBar()
	progressBar.Value = 0.66 // 66% completo

	// Texto do progresso
	progressText := widget.NewLabel("2 de 3 tarefas completas")

	// Organizar layout
	content := container.NewVBox(
		title,
		widget.NewSeparator(),
		taskList,
		progressText,
		progressBar,
	)

	w.SetContent(content)
	w.ShowAndRun()
}

Compile e rode: é isso. Funciona nativamente no seu Linux, macOS ou Windows.

Por que Fyne na v2.8?

Antes da v2.8, o Fyne era uma ótima escolha para MVPs e ferramentas internas. Agora, com performance melhorada e APIs mais maduras, é viável para aplicações de produção mais complexas.

• Cross-platform real — sem múltiplos codebases
• Performance — leaner than Electron, mais rápido que interpretadas
• Simplicidade — Go + Fyne = menos linhas de código que alternativas em C++/Python
• Comunidade crescente — mais exemplos, libs extras, suporte

Conclusão

A v2.8 marca um ponto de maturidade do Fyne. Se você trabalha com Go e precisa de uma GUI desktop, especialmente para aplicações cross-platform, o momento é agora. O framework saiu daquele “legal, mas para produção…” e entrou em “pronto para o mundo real”.

A melhor forma de aprender é colocar a mão na massa — escreva uma pequena ferramenta e veja como é satisfatório ter uma app desktop funcional em poucos minutos.

E é claro, usando 100% do nosso querido e amado Golang.

---

Gostou do conteúdo?

• ✅ Inscreva-se na newsletter para receber mais dicas práticas sobre Go diretamente no seu e-mail!
• 🚀 Conheça a Imersão Golang e leve seus conhecimentos em Go para o próximo nível!

Faça parte da comunidade!

Receba os melhores conteúdos sobre Go, Kubernetes, arquitetura de software, Cloud e esteja sempre atualizado com as tendências e práticas do mercado.