guido 0.12.0

A reactive Rust GUI library using wgpu for Wayland layer shell widgets
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71

# Architecture

This section covers Guido's internal architecture for developers who want to understand how the library works or contribute to it.

## System Overview

```text
┌─────────────────────────────────────────────────────────────────┐
│                          Application                             │
│  ┌─────────────┐  ┌─────────────┐  ┌─────────────────────────┐  │
│  │   Widgets   │  │  Reactive   │  │       Platform          │  │
│  │  Container  │  │   Signals   │  │   Wayland Layer Shell   │  │
│  │    Text     │  │    Memo     │  │   Event Loop (calloop)  │  │
│  │   Layout    │  │   Effects   │  │                         │  │
│  └──────┬──────┘  └──────┬──────┘  └───────────┬─────────────┘  │
│         │                │                     │                 │
│         └────────────────┼─────────────────────┘                 │
│                          │                                       │
│                    ┌─────┴─────┐                                 │
│                    │  Renderer │                                 │
│                    │   wgpu    │                                 │
│                    │  glyphon  │                                 │
│                    └───────────┘                                 │
└─────────────────────────────────────────────────────────────────┘
```

## Module Structure

| Module | Purpose |
|--------|---------|
| `reactive/` | Signals, memos, effects |
| `widgets/` | Container, Text, Layout trait |
| `renderer/` | wgpu rendering, shaders, text |
| `platform/` | Wayland layer shell integration |
| `transform.rs` | 2D transformation matrices |

## In This Section

- [System Overview](overview.md) - Module structure and key types
- [Rendering Pipeline](rendering.md) - How shapes and text are drawn
- [Event System](events.md) - Input event flow and handling

## Key Design Decisions

### Fine-Grained Reactivity

Guido uses signals rather than virtual DOM diffing. Widgets are created once; their properties update automatically through signal subscriptions.

### Builder Pattern

All configuration uses the builder pattern with method chaining:

```rust
# extern crate guido;
# use guido::prelude::*;
# fn main() {
container()
    .padding(16.0)
    .background(Color::RED)
    .child(text("Hello"))
# ;
# }
```

### SDF Rendering

Shapes use Signed Distance Fields for resolution-independent rendering with crisp anti-aliasing at any scale.

### Layer Shell Native

Guido is built specifically for Wayland layer shell, not as a general windowing toolkit with layer shell support added later.