---
title: "Rust GUI 2026: Melhores Frameworks Desktop | Rust Brasil"
url: "https://rustlang.com.br/blog/rust-gui-2026/"
markdown_url: "https://rustlang.com.br/blog/rust-gui-2026.MD"
description: "Melhores frameworks GUI em Rust para 2026: Iced, Tauri, Dioxus, egui e Slint. Exemplos de código, comparativo e recomendações práticas."
date: "2026-02-28"
author: "Equipe Rust Brasil"
---

# Rust GUI 2026: Melhores Frameworks Desktop | Rust Brasil

Melhores frameworks GUI em Rust para 2026: Iced, Tauri, Dioxus, egui e Slint. Exemplos de código, comparativo e recomendações práticas.


## Introdução: GUI em Rust Nunca Esteve Tão Madura

Durante anos, a ausência de um framework GUI consolidado foi uma das críticas mais comuns à linguagem Rust. Desenvolvedores que queriam criar aplicações desktop com interface gráfica precisavam lidar com bindings incompletos, APIs instáveis e documentação escassa. Em 2026, esse cenário mudou radicalmente.

O ecossistema GUI de Rust conta hoje com pelo menos seis frameworks robustos, cada um com filosofia e público-alvo distintos. Desde soluções nativas multiplataforma até abordagens híbridas com tecnologias web, há opções maduras para praticamente qualquer necessidade. Se você está acompanhando a evolução do [ecossistema Rust](/ecossistema/), sabe que esse é um dos segmentos que mais cresceu nos últimos dois anos.

Neste artigo, vamos analisar em profundidade os **melhores frameworks GUI em Rust para 2026**: Iced, Tauri, Dioxus, egui, Slint e gtk-rs. Para cada um, apresentamos uma descrição, quando usar, prós e contras, e um exemplo de código funcional. Ao final, trazemos uma tabela comparativa e recomendações por caso de uso.

## Iced: GUI Nativa Inspirada no Elm

O [Iced](https://github.com/iced-rs/iced) é um framework GUI multiplataforma que segue a arquitetura Elm (Model-View-Update). Ele renderiza interfaces de forma nativa usando wgpu como backend gráfico, o que significa que não depende de WebView nem de toolkits do sistema operacional.

### Quando Usar

- Aplicações desktop nativas com visual moderno e customizado
- Projetos que valorizam uma arquitetura funcional e previsível
- Ferramentas internas e dashboards com gráficos e animações

### Prós e Contras

**Prós:** API idiomática em Rust, renderização GPU acelerada, arquitetura limpa e testável, suporte a temas customizados.

**Contras:** Ecossistema de widgets menor que GTK, curva de aprendizado para quem não conhece o padrão Elm, ainda sem suporte mobile estável.

### Exemplo de Código

```rust
use iced::widget::{button, column, text};
use iced::{Element, Task};

#[derive(Default)]
struct Contador {
    valor: i32,
}

#[derive(Debug, Clone)]
enum Mensagem {
    Incrementar,
    Decrementar,
}

impl Contador {
    fn update(&mut self, mensagem: Mensagem) -> Task<Mensagem> {
        match mensagem {
            Mensagem::Incrementar => self.valor += 1,
            Mensagem::Decrementar => self.valor -= 1,
        }
        Task::none()
    }

    fn view(&self) -> Element<Mensagem> {
        column![
            button("+ Incrementar").on_press(Mensagem::Incrementar),
            text(format!("Valor: {}", self.valor)).size(40),
            button("- Decrementar").on_press(Mensagem::Decrementar),
        ]
        .padding(20)
        .spacing(10)
        .into()
    }
}

fn main() -> iced::Result {
    iced::application("Contador Iced", Contador::update, Contador::view)
        .run()
}
```

Para incluir o Iced no seu projeto, adicione ao `Cargo.toml`:

```toml
[dependencies]
iced = "0.13"
```

## Tauri: Aplicações Híbridas Leves

O [Tauri](https://tauri.app/) é um framework para construir aplicações desktop usando Rust no backend e tecnologias web (HTML, CSS, JavaScript/TypeScript) no frontend. Ele utiliza o WebView nativo do sistema operacional, resultando em binários muito menores que o Electron.

### Quando Usar

- Aplicações desktop que se beneficiam de uma interface web rica
- Equipes que já possuem expertise em frontend web (React, Vue, Svelte)
- Projetos que precisam de binários pequenos e baixo consumo de memória

### Prós e Contras

**Prós:** Binários extremamente pequenos (< 5 MB), usa WebView nativo, ecossistema frontend completo, excelente sistema de plugins, suporte a mobile (Android e iOS) a partir do Tauri v2.

**Contras:** Performance da UI depende do WebView, debugging mais complexo entre camadas Rust e JS, a interface não é verdadeiramente nativa.

### Exemplo de Código

Backend Rust com um comando Tauri:

```rust
use tauri::command;

#[command]
fn saudacao(nome: &str) -> String {
    format!("Olá, {}! Bem-vindo ao app Tauri com Rust.", nome)
}

fn main() {
    tauri::Builder::default()
        .invoke_handler(tauri::generate_handler![saudacao])
        .run(tauri::generate_context!())
        .expect("Erro ao iniciar aplicação Tauri");
}
```

No frontend (JavaScript), o comando é chamado assim:

```javascript
import { invoke } from "@tauri-apps/api/core";

const resposta = await invoke("saudacao", { nome: "Maria" });
console.log(resposta); // "Olá, Maria! Bem-vindo ao app Tauri com Rust."
```

Se você está avaliando Tauri versus outras stacks, pode ser interessante ler nosso [comparativo entre Rust e Go](/blog/rust-vs-go-2026/) para entender como Rust se destaca em aplicações de sistema.

## Dioxus: React para Rust

O [Dioxus](https://dioxuslabs.com/) traz o modelo de componentes do React para o mundo Rust. Ele suporta múltiplos targets: desktop (via WebView ou WGPU), web (WebAssembly), mobile e terminal. A sintaxe RSX é familiar para quem vem do React/JSX.

### Quando Usar

- Desenvolvedores que vêm do ecossistema React e querem usar Rust
- Projetos que precisam rodar em múltiplas plataformas com o mesmo código
- Aplicações com interfaces dinâmicas e reativas

### Prós e Contras

**Prós:** Sintaxe RSX intuitiva, hot-reloading, suporte a múltiplos targets com código compartilhado, hooks e estado reativo, comunidade ativa e em rápido crescimento.

**Contras:** Ainda em evolução, API pode ter breaking changes entre versões, ecossistema de componentes de terceiros ainda menor que React.

### Exemplo de Código

```rust
use dioxus::prelude::*;

fn main() {
    dioxus::launch(App);
}

#[component]
fn App() -> Element {
    let mut contador = use_signal(|| 0);

    rsx! {
        div {
            style: "padding: 20px; font-family: sans-serif;",
            h1 { "Contador Dioxus" }
            p { "Valor atual: {contador}" }
            button {
                onclick: move |_| contador += 1,
                "Incrementar"
            }
            button {
                onclick: move |_| contador -= 1,
                "Decrementar"
            }
        }
    }
}
```

## egui: GUI Imediata para Ferramentas e Prototipagem

O [egui](https://github.com/emilk/egui) é uma biblioteca de GUI no modo imediato (immediate mode), inspirada em Dear ImGui. Ele é ideal para ferramentas de desenvolvimento, editores, painéis de debug e prototipagem rápida.

### Quando Usar

- Ferramentas internas, editores e painéis de debug
- Prototipagem rápida de interfaces
- Aplicações que precisam integrar GUI em engines gráficas ou jogos
- Visualização de dados em tempo real

### Prós e Contras

**Prós:** Extremamente simples de usar, sem estado externo para gerenciar, renderização instantânea, funciona em WebAssembly, integração fácil com wgpu e OpenGL.

**Contras:** Visual menos polido para aplicações voltadas ao consumidor final, não segue convenções nativas de cada sistema operacional, menos adequado para formulários complexos.

### Exemplo de Código

```rust
use eframe::egui;

fn main() -> eframe::Result {
    let opcoes = eframe::NativeOptions::default();
    eframe::run_native(
        "Meu App egui",
        opcoes,
        Box::new(|_cc| Ok(Box::new(MeuApp::default()))),
    )
}

#[derive(Default)]
struct MeuApp {
    nome: String,
    idade: u32,
}

impl eframe::App for MeuApp {
    fn update(&mut self, ctx: &egui::Context, _frame: &mut eframe::Frame) {
        egui::CentralPanel::default().show(ctx, |ui| {
            ui.heading("Cadastro");
            ui.horizontal(|ui| {
                ui.label("Nome:");
                ui.text_edit_singleline(&mut self.nome);
            });
            ui.add(egui::Slider::new(&mut self.idade, 0..=120).text("Idade"));

            if ui.button("Enviar").clicked() {
                println!("Nome: {}, Idade: {}", self.nome, self.idade);
            }
        });
    }
}
```

Para usar egui com eframe, adicione ao `Cargo.toml`:

```toml
[dependencies]
eframe = "0.30"
```

## Slint: GUI Declarativa com Linguagem Própria

O [Slint](https://slint.dev/) (anteriormente SixtyFPS) é um toolkit GUI declarativo que utiliza uma linguagem de marcação própria (`.slint`) para definir interfaces. Ele gera código nativo altamente otimizado e suporta desktop, embedded e WebAssembly.

### Quando Usar

- Aplicações com design visual sofisticado e animações
- Projetos embarcados (microcontroladores, painéis industriais)
- Equipes com designers que querem participar da criação da UI
- Aplicações comerciais (licença comercial disponível)

### Prós e Contras

**Prós:** Linguagem declarativa intuitiva, preview em tempo real, performance excelente em dispositivos embarcados, separação limpa entre UI e lógica de negócios, ferramentas de design integradas.

**Contras:** Linguagem proprietária adiciona complexidade ao projeto, licença dual (GPLv3 ou comercial paga), ecossistema menor que outras opções.

### Exemplo de Código

Arquivo `ui/app.slint`:

```slint
export component AppWindow inherits Window {
    title: "Contador Slint";
    width: 300px;
    height: 200px;

    in-out property <int> valor: 0;
    callback incrementar();
    callback decrementar();

    VerticalLayout {
        alignment: center;
        spacing: 10px;
        padding: 20px;

        Text {
            text: "Valor: " + valor;
            font-size: 24px;
            horizontal-alignment: center;
        }
        HorizontalLayout {
            alignment: center;
            spacing: 10px;
            Button { text: "+ Incrementar"; clicked => { incrementar(); } }
            Button { text: "- Decrementar"; clicked => { decrementar(); } }
        }
    }
}
```

Arquivo `src/main.rs`:

```rust
slint::include_modules!();

fn main() {
    let janela = AppWindow::new().unwrap();

    let janela_fraca = janela.as_weak();
    janela.on_incrementar(move || {
        let janela = janela_fraca.unwrap();
        janela.set_valor(janela.get_valor() + 1);
    });

    let janela_fraca = janela.as_weak();
    janela.on_decrementar(move || {
        let janela = janela_fraca.unwrap();
        janela.set_valor(janela.get_valor() - 1);
    });

    janela.run().unwrap();
}
```

## gtk-rs: Bindings GTK Nativos

O [gtk-rs](https://gtk-rs.org/) fornece bindings seguros para as bibliotecas GTK4, GLib e GIO. É a escolha natural para aplicações que devem se integrar perfeitamente ao ecossistema GNOME e ao desktop Linux.

### Quando Usar

- Aplicações para o ecossistema GNOME/Linux
- Projetos que precisam de look-and-feel nativo no Linux
- Aplicações com widgets complexos (árvores, listas virtualizadas, rich text)
- Quando o acesso ao ecossistema completo de bibliotecas GLib é necessário

### Prós e Contras

**Prós:** Toolkit maduro e estável (GTK4), enorme variedade de widgets, excelente integração com o desktop Linux, acessibilidade robusta, ampla documentação.

**Contras:** Experiência no macOS e Windows é inferior à do Linux, dependências externas (bibliotecas GTK devem estar instaladas), API verbosa em comparação com frameworks mais modernos.

### Exemplo de Código

```rust
use gtk4::prelude::*;
use gtk4::{Application, ApplicationWindow, Button, Label, Box as GtkBox, Orientation};
use std::cell::Cell;
use std::rc::Rc;

fn main() {
    let app = Application::builder()
        .application_id("br.com.rustlang.exemplo")
        .build();

    app.connect_activate(|app| {
        let valor = Rc::new(Cell::new(0i32));
        let label = Label::new(Some("Valor: 0"));
        label.set_margin_top(10);
        label.set_margin_bottom(10);

        let valor_inc = valor.clone();
        let label_inc = label.clone();
        let btn_inc = Button::with_label("+ Incrementar");
        btn_inc.connect_clicked(move |_| {
            valor_inc.set(valor_inc.get() + 1);
            label_inc.set_text(&format!("Valor: {}", valor_inc.get()));
        });

        let valor_dec = valor.clone();
        let label_dec = label.clone();
        let btn_dec = Button::with_label("- Decrementar");
        btn_dec.connect_clicked(move |_| {
            valor_dec.set(valor_dec.get() - 1);
            label_dec.set_text(&format!("Valor: {}", valor_dec.get()));
        });

        let caixa = GtkBox::new(Orientation::Vertical, 5);
        caixa.set_margin_top(20);
        caixa.set_margin_bottom(20);
        caixa.set_margin_start(20);
        caixa.set_margin_end(20);
        caixa.append(&btn_inc);
        caixa.append(&label);
        caixa.append(&btn_dec);

        let janela = ApplicationWindow::builder()
            .application(app)
            .title("Contador GTK-rs")
            .child(&caixa)
            .default_width(300)
            .default_height(200)
            .build();

        janela.present();
    });

    app.run();
}
```

Para usar gtk-rs, adicione ao `Cargo.toml`:

```toml
[dependencies]
gtk4 = "0.9"
```

## Tabela Comparativa dos Frameworks GUI em Rust

| Característica | Iced | Tauri | Dioxus | egui | Slint | gtk-rs |
|---|---|---|---|---|---|---|
| **Arquitetura** | Elm (MVU) | Híbrida (Rust + Web) | Componentes (React) | Modo imediato | Declarativa (.slint) | Orientada a objetos |
| **Renderização** | wgpu (GPU) | WebView nativo | WebView / WGPU | wgpu / OpenGL | Nativa / Software | GTK4 nativo |
| **Maturidade** | Alta | Muito alta | Média-alta | Alta | Média-alta | Muito alta |
| **Facilidade de uso** | Média | Alta (se sabe web) | Alta (se sabe React) | Muito alta | Alta | Média |
| **Desktop** | Windows, macOS, Linux | Windows, macOS, Linux | Windows, macOS, Linux | Windows, macOS, Linux | Windows, macOS, Linux | Windows, macOS, Linux |
| **Mobile** | Experimental | Android, iOS (v2) | Android, iOS | Limitado | Embarcados | Limitado |
| **Web (WASM)** | Sim | N/A (usa web nativamente) | Sim | Sim | Sim | Limitado |
| **Tamanho do binário** | Médio (~10 MB) | Pequeno (~3-5 MB) | Médio (~8 MB) | Pequeno (~5 MB) | Pequeno (~3 MB) | Grande (deps GTK) |
| **Licença** | MIT | MIT / Apache-2.0 | MIT / Apache-2.0 | MIT / Apache-2.0 | GPLv3 / Comercial | MIT |
| **Ideal para** | Apps desktop modernas | Apps híbridas | Apps multiplataforma | Ferramentas / debug | Embarcados / design | Apps Linux / GNOME |

## Como Escolher: Recomendações por Caso de Uso

A escolha do framework certo depende do contexto do seu projeto. Aqui estão nossas recomendações:

Kotlin oferece Compose Multiplatform para desktop — veja <a href="https://kotlin.dev.br/blog/kotlin-compose-multiplatform-desktop/" target="_blank" rel="noopener" onclick="umami.track('portfolio-site-click', { destination: 'kotlin.dev.br' })">Compose Multiplatform</a>. Zig também tem opções para GUI — confira em <a href="https://ziglang.com.br/artigos/zig-gui-interfaces-graficas/" target="_blank" rel="noopener" onclick="umami.track('portfolio-site-click', { destination: 'ziglang.com.br' })">interfaces gráficas com Zig</a>.

**Para aplicações desktop com visual nativo no Linux:** gtk-rs continua sendo a melhor opção. A maturidade do GTK4, a variedade de widgets e a integração com o desktop GNOME são imbatíveis.

**Para aplicações desktop modernas multiplataforma:** Iced é a escolha mais sólida se você quer ficar 100% no ecossistema Rust. A arquitetura Elm torna o código previsível e fácil de testar.

**Para equipes com experiência em frontend web:** Tauri oferece o melhor dos dois mundos. Você mantém suas habilidades em React, Vue ou Svelte no frontend e ganha toda a performance e segurança do Rust no backend.

**Para prototipagem rápida e ferramentas internas:** egui é imbatível em simplicidade. Em poucas linhas você tem uma interface funcional. Perfeito para dashboards, editores e painéis de debug.

**Para projetos que precisam rodar em múltiplas plataformas (incluindo mobile):** Dioxus é o mais versátil, permitindo compartilhar código entre desktop, web e mobile com a mesma base.

**Para dispositivos embarcados e interfaces com design sofisticado:** Slint foi projetado exatamente para isso. A linguagem declarativa facilita a criação de interfaces bonitas com animações fluidas, mesmo em hardware limitado.

Para explorar mais bibliotecas e ferramentas do ecossistema Rust, visite nossa seção de [projetos](/projetos/) e confira também nossos [artigos técnicos](/artigos/) com tutoriais aprofundados.

## Conclusão

O desenvolvimento GUI em Rust amadureceu significativamente em 2026. Não existe mais a desculpa de que "Rust não serve para GUI". Cada um dos seis frameworks apresentados resolve um conjunto específico de problemas, e todos são ativamente mantidos com comunidades crescentes.

Se você está começando agora, nossa sugestão é escolher o framework que mais se alinha com sua experiência prévia e com os requisitos do projeto. Experimente o egui para algo rápido, o Tauri se você vem do mundo web, ou o Iced se quer uma experiência puramente Rust. O importante é começar a construir.

O futuro das interfaces gráficas em Rust é promissor, e a comunidade brasileira está acompanhando de perto. Continue acompanhando o [Rust Brasil](/blog/) para mais conteúdos atualizados sobre a linguagem.

## Perguntas Frequentes

### Qual o melhor framework GUI em Rust para iniciantes?

O egui é o mais simples para começar. Sua API no modo imediato elimina a necessidade de gerenciar estado complexo e permite criar interfaces funcionais em poucas linhas de código. Para quem já tem experiência com desenvolvimento web, o Tauri também é excelente porque permite usar HTML, CSS e JavaScript no frontend.

### Rust é bom para desenvolvimento de aplicações desktop?

Sim. Em 2026, Rust é uma excelente escolha para aplicações desktop. A linguagem oferece performance nativa, segurança de memória garantida em tempo de compilação e um ecossistema GUI diversificado. Frameworks como Iced, Tauri e Slint produzem aplicações profissionais multiplataforma com binários pequenos e baixo consumo de recursos.

### Tauri é melhor que Electron?

Tauri supera o Electron em praticamente todas as métricas técnicas: binários até 100 vezes menores, consumo de memória significativamente menor e melhor performance. A principal vantagem do Electron ainda é o ecossistema mais maduro e a familiaridade de muitas equipes. Porém, com o Tauri v2 suportando mobile e uma comunidade cada vez maior, a diferença diminui a cada dia.

### Posso criar apps mobile com GUI em Rust?

Sim, embora o suporte mobile ainda esteja em evolução. O Tauri v2 suporta Android e iOS oficialmente. O Dioxus também permite compilar para mobile. O Slint funciona em dispositivos embarcados com tela. Para projetos mobile críticos, é recomendável avaliar a maturidade do suporte mobile do framework escolhido antes de se comprometer.

<script type="application/ld+json">
{
  "@context": "https://schema.org",
  "@type": "FAQPage",
  "mainEntity": [
    {
      "@type": "Question",
      "name": "Qual o melhor framework GUI em Rust para iniciantes?",
      "acceptedAnswer": {
        "@type": "Answer",
        "text": "O egui é o mais simples para começar. Sua API no modo imediato elimina a necessidade de gerenciar estado complexo e permite criar interfaces funcionais em poucas linhas de código. Para quem já tem experiência com desenvolvimento web, o Tauri também é excelente porque permite usar HTML, CSS e JavaScript no frontend."
      }
    },
    {
      "@type": "Question",
      "name": "Rust é bom para desenvolvimento de aplicações desktop?",
      "acceptedAnswer": {
        "@type": "Answer",
        "text": "Sim. Em 2026, Rust é uma excelente escolha para aplicações desktop. A linguagem oferece performance nativa, segurança de memória garantida em tempo de compilação e um ecossistema GUI diversificado. Frameworks como Iced, Tauri e Slint produzem aplicações profissionais multiplataforma com binários pequenos e baixo consumo de recursos."
      }
    },
    {
      "@type": "Question",
      "name": "Tauri é melhor que Electron?",
      "acceptedAnswer": {
        "@type": "Answer",
        "text": "Tauri supera o Electron em praticamente todas as métricas técnicas: binários até 100 vezes menores, consumo de memória significativamente menor e melhor performance. A principal vantagem do Electron ainda é o ecossistema mais maduro e a familiaridade de muitas equipes. Porém, com o Tauri v2 suportando mobile e uma comunidade cada vez maior, a diferença diminui a cada dia."
      }
    },
    {
      "@type": "Question",
      "name": "Posso criar apps mobile com GUI em Rust?",
      "acceptedAnswer": {
        "@type": "Answer",
        "text": "Sim, embora o suporte mobile ainda esteja em evolução. O Tauri v2 suporta Android e iOS oficialmente. O Dioxus também permite compilar para mobile. O Slint funciona em dispositivos embarcados com tela. Para projetos mobile críticos, é recomendável avaliar a maturidade do suporte mobile do framework escolhido antes de se comprometer."
      }
    }
  ]
}
</script>