Dewey — Agentic-First GUI Framework

Dewey is a backend-agnostic Rust GUI framework with a pluggable Painter rendering abstraction and optional GPU-accelerated rendering via egui/wgpu. It provides a complete semantic ontology over every UI widget. AI agents can discover, inspect, and control graphical applications through a structured JSON Lines protocol — no screen-scraping, no pixel matching, no accessibility-tree hacking.

Dewey does for GUIs what Louie does for TUIs.

Copyright (c) NERVOSYS. All rights reserved.

Features

Core Architecture

• Elm Architecture — Immutable model, message-driven updates, pure view functions
• 29 Widgets — Button, Label, Input, TextArea, Table, Tree, Menu, Modal, Canvas, ColorPicker, Toolbar, Splitter, CommandPalette, VirtualList, Chart, DatePicker, RichText, and more
• Backend-Agnostic Rendering — Abstract Painter trait with pluggable backends (egui/wgpu, web/wasm32, software rasterizer, test/headless)
• Full Semantic Ontology — Every widget exposes its schema, capabilities, actions, and semantic role
• Layout Engine — Constraint-based layout with flex distribution
• Focus Management — Ring-buffer tab navigation
• Overlay System — Modal dialogs and overlay stacking

Agent & AI Integration

• Agent Protocol — JSON Lines over stdin/stdout with batch actions, protocol negotiation, and state-diff subscriptions
• WebSocket Transport — Same agent protocol over WebSocket for remote and cross-language agent control
• Headless Driver — Run and test apps without a GPU or display

Rendering Backends (6)

• GPU Backend — egui/wgpu hardware-accelerated rendering
• agpu Backend — Vulkan-first wgpu/winit backend with complete GPU resource abstraction and full ontology (agpu crate)
• Web Backend — WebPainter targeting wasm32/Canvas 2D for browser deployment
• Software Rasterizer — ImagePainter for CPU-only rendering and screenshot generation
• Test Backend — TestBackend records every draw call for assertion; zero GPU required
• Null Backend — NullPainter for headless/CI environments

Platform Integration

• Cross-Platform — Windows, macOS, Linux, and Web (wasm32)
• Multi-Window — WindowManager for opening, closing, focusing, and managing multiple windows
• System Tray — TrayBackend trait with configurable menus, tooltips, and tray icons
• Native File Dialogs — DialogBackend for open/save dialogs and message boxes
• Drag & Drop — Full drag-and-drop event pipeline with typed payloads (files, text, custom data)

Theming & Styling

• Token-Based Themes — Built-in dark and light presets with full JSON serialization
• Theme Hot-Reload — ThemeWatcher monitors theme files and live-reloads on change
• Accessibility — ARIA-like semantic roles on every UI node for screen readers and assistive agents

Performance & Optimization

• GPU Render Batching — RenderBatch with automatic quad merging and draw-call optimization
• Arena Allocator — Bump allocator for zero-fragmentation per-frame allocation
• Buffer Pooling — VecPool for reusable buffer allocation with zero syscall overhead
• Built-in Profiler — Profiler with per-frame timing, FPS tracking, widget counting, and history
• Animation Engine — 34 easing functions, tweens, spring physics, timelines, keyframe sequences

Extensibility

• Plugin System — Plugin trait with lifecycle hooks (init, on_frame, on_shutdown) and PluginRegistry
• Internationalization — I18n framework with locale fallback chains, message catalogs, and t_fmt() interpolation

Data & State

• Data-Bound Table — Sorting, filtering, and pagination built into the Table widget
• State Persistence — Save/restore model state to disk as JSON
• Virtual Scrolling — Efficient rendering for lists with thousands of items
• Async Tasks — Cancellable tasks with timeout support

Quick Start

Add Dewey to your Cargo.toml:

[dependencies]

dewey = "1"

use dewey::prelude::*;

struct App { count: i32 }

#[derive(Debug)]
enum Msg { Increment, Decrement }

impl Model for App {
    type Msg = Msg;

    fn update(&mut self, msg: Msg) -> Command<Msg> {
        match msg {
            Msg::Increment => self.count += 1,
            Msg::Decrement => self.count -= 1,
        }
        Command::None
    }

    fn view(&self, frame: &mut Frame<'_>) {
        let area = frame.area;
        Label::new(format!("Count: {}", self.count)).render(area, frame);
    }

    fn handle_event(&self, _event: Event) -> Option<Msg> { None }
}

fn main() -> Result<(), eframe::Error> {
    Program::new(App { count: 0 }).run()
}

Using agpu (Vulkan-First GPU Backend)

For a standalone Vulkan-first GPU backend without egui:

[dependencies]

dewey = { version = "1", default-features = false, features = ["agpu-backend"] }

use dewey::backend::agpu_backend::AgpuProgram;
use dewey::prelude::*;

fn main() -> std::result::Result<(), Box<dyn std::error::Error>> {
    AgpuProgram::new(App { count: 0 }).run()
}

Agent Protocol

Dewey speaks JSON Lines over stdin/stdout. Any language that can read/write lines of JSON can drive the UI:

{"id":1,"request":"QueryOntology"}
{"id":2,"request":{"GetWidgetState":{"agent_id":"counter_label"}}}
{"id":3,"request":{"PerformAction":{"agent_id":"increment_btn","action":"click","params":{}}}}
{"id":4,"request":"ListActions"}
{"id":5,"request":"Screenshot"}

Architecture

┌──────────┐   Event   ┌──────────┐  Command  ┌──────────┐
│  Backend │ ────────→ │  Model   │ ────────→ │ Runtime  │
│(Painter) │           │ (update) │           │ (Program)│
│          │ ←──────── │  (view)  │ ←──────── │          │
└──────────┘   Frame   └──────────┘           └──────────┘
      ↕                      ↕
┌──────────┐         ┌──────────────┐
│  Widgets │         │  Ontology    │
│  (30)    │         │  (Registry)  │
└──────────┘         └──────────────┘
                             ↕
                       ┌──────────┐
                       │  Agent   │
                       │ Protocol │
                       └──────────┘

Widget Inventory

Competitive Landscape

Feature Comparison Matrix

Dewey's Unique Advantages

1. Agent-native — The only GUI framework with a built-in semantic protocol for AI agents (JSON Lines + WebSocket)
2. Full ontology — Every widget exposes structured schema, capabilities, typed actions, and semantic roles — no screen-scraping or accessibility-tree hacking
3. 6 rendering backends — GPU (egui/wgpu), agpu (Vulkan-first), Web (wasm32/Canvas 2D), software rasterizer (ImagePainter), test (TestBackend), and null — swap backends without touching widget code
4. Headless-first testing — TestBackend records every draw call for assertion; zero GPU, zero display required
5. Elm architecture — Predictable state management with immutable models and message-driven updates
6. Memory-optimized — Arena bump allocator and VecPool buffer reuse eliminate per-frame allocation overhead
7. Built-in profiler — Per-frame timing, FPS tracking, widget counting, and configurable history — no external tools needed
8. Plugin-extensible — Plugin trait with full lifecycle hooks and PluginRegistry for modular architecture
9. i18n-ready — Built-in I18n framework with locale fallback chains and message catalogs — no third-party crate required
10. Platform-complete — Multi-window, system tray, native file dialogs, and drag-and-drop with typed payloads — all built in

* Electron/Tauri support agent interaction only through fragile accessibility trees or DOM scraping.

Examples

cargo run --example hello               # Minimal window

cargo run --example counter             # Interactive counter (Elm architecture)

cargo run --example agent_demo          # Agent protocol demo

cargo run --example showcase            # Widget showcase gallery

cargo run --example canvas_drawing      # Canvas drawing demo

cargo run --example ontology_explorer   # Headless ontology discovery

cargo run --example agent_headless      # Full headless agent session

cargo run --example chat                # Chat interface demo

cargo run --example counter_agpu --features agpu-backend --no-default-features  # Counter using agpu GPU backend

License

AGPL-3.0-or-later — free for open-source use. Commercial licenses are available from NERVOSYS for proprietary/closed-source applications.