Fyne vient d’arriver à la version 2.8 avec plus de mille commits, apportant de nouveaux composants graphiques, des API améliorées et des optimisations qui rendent le développement d’applications de bureau avec Go encore plus pratique. Dans cet article, nous allons explorer ce qui a changé et comment vous pouvez tirer parti de ces nouveautés.
Qu’est-ce que Fyne ?
Fyne est un framework Go permettant de construire des interfaces graphiques modernes qui fonctionnent sur Linux, macOS et Windows avec le même code. Contrairement à d’autres approches qui génèrent des binaires lourds, Fyne offre un contrôle précis de la performance et de la taille des fichiers — idéal pour des applications de bureau légères et réactives.
Si vous travaillez avec Go et que vous vous êtes déjà demandé comment réaliser une bonne GUI sans plonger dans le C++, Fyne est la réponse.
Nouveautés de la v2.8
Nouveaux composants graphiques
La v2.8 introduit un nouveau package canvas avec un support étendu pour les graphiques et le rendu. Désormais, vous pouvez créer des visualisations plus élaborées sans dépendre de bibliothèques externes complexes.
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 retravaillées
L’API des bindings a été entièrement repensée dans la v2.8. Désormais, il est bien plus intuitif de lier les données à l’interface utilisateur — moins de code boilerplate, plus de clarté.
// Avant : beaucoup de code de bindings manuels
// Maintenant : direct et simple
type Person struct {
Name string
Age int
}
person := Person{Name: "João", Age: 30}
nameBinding := binding.BindString(&person.Name)
nameEntry := widget.NewEntryWithData(nameBinding)Améliorations de performance
Le renderer a été optimisé de manière significative. Les applications Fyne utilisent désormais moins de CPU au repos et le défilement est bien plus fluide — une victoire pour ceux qui travaillent avec de grandes listes.
Dans la pratique : un exemple réel
Je vais montrer une application simple qui exploite les nouveautés — un gestionnaire de tâches avec une visualisation graphique de l’avancement.
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))
// Titre
title := widget.NewLabel("Minha Interface")
// Liste des tâches
tasks := []string{"Implementar API", "Documentação", "Testes unitários"}
taskList := widget.NewList(
func() int { return len(tasks) },
func() fyne.CanvasObject {
return .NewLabel("")
},
func(id widget.ListItemID, obj fyne.CanvasObject) {
obj.(*.Label).SetText(tasks[id])
},
)
// Barre de progression visuelle (nouvelle dans v2.8)
progressBar := widget.NewProgressBar()
progressBar.Value = 0.66 // 66% complet
// Texte de progression
progressText := widget.NewLabel("2 de 3 tâches complétées")
// Organisation de la mise en page
content := container.NewVBox(
title,
widget.NewSeparator(),
taskList,
progressText,
progressBar,
)
w.SetContent(content)
w.ShowAndRun()
}Compilez et lancez : c’est tout. Cela fonctionne nativement sur votre Linux, macOS ou Windows.
Pourquoi Fyne en v2.8 ?
Avant la v2.8, Fyne était un excellent choix pour les MVP et les outils internes. Désormais, avec des performances améliorées et des API plus matures, il est viable pour des applications de production plus complexes.
- Cross-platform véritable — sans multiples bases de code
- Performance — Plus léger qu’Electron, plus rapide que les solutions interprétées
- Simplicité — Go + Fyne = moins de lignes de code que les alternatives en C++/Python
- Communauté croissante — plus d’exemples, de bibliothèques supplémentaires et de support
Conclusion
La v2.8 marque une maturité du Fyne. Si vous travaillez avec Go et que vous avez besoin d’une GUI de bureau, surtout pour des applications cross-platform, le moment est venu. Le framework est passé de « sympa, mais pour la production… » à « prêt pour le monde réel ».
La meilleure façon d’apprendre est de passer à l’action — écrivez un petit outil et voyez comme il est satisfaisant d’avoir une application de bureau fonctionnelle en quelques minutes.
Et bien sûr, en utilisant 100 % de notre cher et adoré Golang.
