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 — ideal 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")

    // Novo suporte a gráficos vetoriais mais completos
    circle := canvas.NewCircle(color.White)
    circle.StrokeColor = color.RGBA{255, 25, 25, 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: muito código de bindings 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 o 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 - Fyne v2.8")
    w.Resize(fyne.NewSize(700, 500))

    // Título
    title := widget.NewLabel("Minha Interface")

    // 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 widget.ListItemID, obj fyne.CanvasObject) {
            obj.(*widget.Label).SetText(tasks[id])
        },
    )

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

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

    // Organiza 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 e 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 de “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 um app desktop funcional em poucos minutos.

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