pierrelf.com
web engine - experimental web browser
Initialize workspace: 15-crate browser engine scaffold
Pure Rust web browser engine targeting macOS ARM. Zero external
dependencies. Workspace with 15 crates: platform, url, encoding,
html, css, dom, style, layout, text, net, crypto, image, render,
js, browser. All inter-crate dependencies wired. Builds clean
with clippy and fmt.
Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>
+692
+1
.gitignore
+1
.gitignore
···
1
+
/target
+134
CLAUDE.md
+134
CLAUDE.md
···
1
+
# we — Agent Guide
2
+
3
+
## Architecture
4
+
5
+
`we` is a from-scratch web browser engine in pure Rust targeting macOS ARM (aarch64-apple-darwin). Zero external crate dependencies. Every subsystem — crypto, TLS, font parsing, image decoding, JS engine — is implemented in Rust.
6
+
7
+
### Crate Map
8
+
9
+
```
10
+
browser ─┬─ platform (macOS FFI: libobjc, AppKit, CoreGraphics, Metal)
11
+
├─ net ──────── url ──── encoding
12
+
│ └── crypto
13
+
├─ html ─────── dom
14
+
│ └── encoding
15
+
├─ css
16
+
├─ dom
17
+
├─ style ────── dom, css
18
+
├─ layout ───── dom, style, css, text
19
+
├─ text (standalone: font parsing, shaping, rasterization)
20
+
├─ render ───── platform, layout, dom, css, text, image
21
+
├─ js ───────── dom
22
+
├─ url
23
+
├─ encoding
24
+
└─ image (standalone: PNG, JPEG, GIF, WebP)
25
+
```
26
+
27
+
Standalone crates (no workspace deps): `platform`, `encoding`, `css`, `dom`, `crypto`, `text`, `image`.
28
+
29
+
## Commands
30
+
31
+
```sh
32
+
# Build
33
+
cargo build --workspace
34
+
35
+
# Run the browser
36
+
cargo run -p we-browser
37
+
38
+
# Test
39
+
cargo test --workspace
40
+
41
+
# Clippy (treat warnings as errors)
42
+
cargo clippy --workspace -- -D warnings
43
+
44
+
# Format
45
+
cargo fmt --all
46
+
cargo fmt --all --check # CI check
47
+
48
+
# Single crate
49
+
cargo test -p we-html
50
+
cargo clippy -p we-css -- -D warnings
51
+
```
52
+
53
+
## Conventions
54
+
55
+
### Zero External Dependencies
56
+
No crates.io dependencies. Everything is implemented in workspace crates. If you need functionality, build it.
57
+
58
+
### Rust Edition
59
+
Rust 2021. Workspace-level `edition = "2021"`.
60
+
61
+
### `unsafe` Policy
62
+
`unsafe` is allowed ONLY in:
63
+
- `platform` — macOS FFI calls (Obj-C runtime, CoreGraphics, Metal)
64
+
- `crypto` — constant-time operations, assembly optimizations
65
+
- `js` — JIT compiler (writing/executing machine code), GC pointer manipulation
66
+
67
+
All other crates must be 100% safe Rust. If you think you need `unsafe` elsewhere, find another way.
68
+
69
+
### Pure Rust Mandate
70
+
We own the full stack. The following are **forbidden**:
71
+
- ImageIO (use `image` crate)
72
+
- CoreText (use `text` crate)
73
+
- Security.framework (use `crypto` crate)
74
+
- Any other system framework for functionality we can implement
75
+
76
+
The ONLY allowed system APIs are:
77
+
- `libobjc.dylib` — Objective-C runtime
78
+
- AppKit — windowing and event loop
79
+
- CoreGraphics — bitmap rendering surface
80
+
- Metal — GPU compositor
81
+
82
+
### JavaScript Engine
83
+
- Register-based bytecode (not stack-based) — designed for JIT from day one
84
+
- Bytecode format encodes register operands directly
85
+
- GC: tri-color mark-and-sweep (white/gray/black)
86
+
- JIT: AArch64 baseline compiler (Phase 15)
87
+
88
+
### Code Style
89
+
- Run `cargo fmt` before committing
90
+
- Run `cargo clippy --workspace -- -D warnings` — must pass clean
91
+
- Keep functions short and focused
92
+
- Prefer `Result<T, E>` over panics for recoverable errors
93
+
- Tests go in `#[cfg(test)] mod tests` in the same file, or in `tests/` directories for integration tests
94
+
95
+
## Workflow
96
+
97
+
1. Pick an issue from tangled
98
+
2. Create a worktree: `git worktree add ../we-<branch> -b <branch>`
99
+
3. Implement, write tests
100
+
4. `cargo clippy --workspace -- -D warnings`
101
+
5. `cargo fmt --all --check`
102
+
6. `cargo test --workspace`
103
+
7. Commit and push
104
+
8. Create PR via tangled: `tangled pr create --title "..." --body "..."`
105
+
9. After merge, clean up: `git worktree remove ../we-<branch>`
106
+
107
+
## Tangled CLI Cheat Sheet
108
+
109
+
```sh
110
+
# Issues
111
+
tangled issue list
112
+
tangled issue create --title "..." --body "..."
113
+
tangled issue show <id>
114
+
115
+
# Pull requests
116
+
tangled pr list
117
+
tangled pr create --title "..." --body "..."
118
+
tangled pr show <id>
119
+
120
+
# Repo
121
+
tangled repo show
122
+
```
123
+
124
+
## Test Suites
125
+
126
+
| Suite | Location | Run |
127
+
|-------|----------|-----|
128
+
| html5lib-tests | `tests/html5lib-tests/` | `cargo test -p we-html` |
129
+
| Test262 | `tests/test262/` | `cargo test -p we-js` |
130
+
| Acid1/Acid2 | loaded via URL | manual: `cargo run -p we-browser -- <url>` |
131
+
| WPT | `tests/wpt/` | `cargo test -p we-browser --test wpt` |
132
+
| Unit tests | each crate | `cargo test --workspace` |
133
+
134
+
Test data repos are git submodules under `tests/`.
+110
Cargo.lock
+110
Cargo.lock
···
1
+
# This file is automatically @generated by Cargo.
2
+
# It is not intended for manual editing.
3
+
version = 4
4
+
5
+
[[package]]
6
+
name = "we-browser"
7
+
version = "0.1.0"
8
+
dependencies = [
9
+
"we-css",
10
+
"we-dom",
11
+
"we-encoding",
12
+
"we-html",
13
+
"we-image",
14
+
"we-js",
15
+
"we-layout",
16
+
"we-net",
17
+
"we-platform",
18
+
"we-render",
19
+
"we-style",
20
+
"we-text",
21
+
"we-url",
22
+
]
23
+
24
+
[[package]]
25
+
name = "we-crypto"
26
+
version = "0.1.0"
27
+
28
+
[[package]]
29
+
name = "we-css"
30
+
version = "0.1.0"
31
+
32
+
[[package]]
33
+
name = "we-dom"
34
+
version = "0.1.0"
35
+
36
+
[[package]]
37
+
name = "we-encoding"
38
+
version = "0.1.0"
39
+
40
+
[[package]]
41
+
name = "we-html"
42
+
version = "0.1.0"
43
+
dependencies = [
44
+
"we-dom",
45
+
"we-encoding",
46
+
]
47
+
48
+
[[package]]
49
+
name = "we-image"
50
+
version = "0.1.0"
51
+
52
+
[[package]]
53
+
name = "we-js"
54
+
version = "0.1.0"
55
+
dependencies = [
56
+
"we-dom",
57
+
]
58
+
59
+
[[package]]
60
+
name = "we-layout"
61
+
version = "0.1.0"
62
+
dependencies = [
63
+
"we-css",
64
+
"we-dom",
65
+
"we-style",
66
+
"we-text",
67
+
]
68
+
69
+
[[package]]
70
+
name = "we-net"
71
+
version = "0.1.0"
72
+
dependencies = [
73
+
"we-crypto",
74
+
"we-url",
75
+
]
76
+
77
+
[[package]]
78
+
name = "we-platform"
79
+
version = "0.1.0"
80
+
81
+
[[package]]
82
+
name = "we-render"
83
+
version = "0.1.0"
84
+
dependencies = [
85
+
"we-css",
86
+
"we-dom",
87
+
"we-image",
88
+
"we-layout",
89
+
"we-platform",
90
+
"we-text",
91
+
]
92
+
93
+
[[package]]
94
+
name = "we-style"
95
+
version = "0.1.0"
96
+
dependencies = [
97
+
"we-css",
98
+
"we-dom",
99
+
]
100
+
101
+
[[package]]
102
+
name = "we-text"
103
+
version = "0.1.0"
104
+
105
+
[[package]]
106
+
name = "we-url"
107
+
version = "0.1.0"
108
+
dependencies = [
109
+
"we-encoding",
110
+
]
+23
Cargo.toml
+23
Cargo.toml
···
1
+
[workspace]
2
+
resolver = "2"
3
+
members = [
4
+
"crates/platform",
5
+
"crates/url",
6
+
"crates/encoding",
7
+
"crates/html",
8
+
"crates/css",
9
+
"crates/dom",
10
+
"crates/style",
11
+
"crates/layout",
12
+
"crates/text",
13
+
"crates/net",
14
+
"crates/crypto",
15
+
"crates/image",
16
+
"crates/render",
17
+
"crates/js",
18
+
"crates/browser",
19
+
]
20
+
21
+
[workspace.package]
22
+
edition = "2021"
23
+
license = "MIT"
+210
PLAN.md
+210
PLAN.md
···
1
+
# we — Development Plan
2
+
3
+
A from-scratch web browser engine in pure Rust. macOS ARM only. Zero external crate dependencies.
4
+
5
+
---
6
+
7
+
## Phase 1: Platform Layer
8
+
9
+
**Goal:** Open a window on macOS, draw pixels, handle input events.
10
+
11
+
- Objective-C runtime FFI (`objc_msgSend`, `objc_getClass`, `sel_registerName`, `class_addMethod`, `objc_allocateClassPair/registerClassPair`)
12
+
- Rust wrappers: `msg_send!` macro, `Class`, `Sel`, `Id` types
13
+
- CoreFoundation minimal bindings (`CFString`, `CFRetain`/`CFRelease`)
14
+
- AppKit FFI: `NSApplication`, `NSWindow`, `NSView`, `NSAutoreleasePool`
15
+
- CoreGraphics rendering surface: `CGContext`, `CGBitmapContext`, `CGColorSpace`
16
+
- Custom `NSView` subclass overriding `drawRect:`
17
+
- Basic event handling: window close, resize, key/mouse events
18
+
- `cargo run -p browser` opens a blank window with a colored rectangle
19
+
20
+
## Phase 2: Pure Rust Font Engine
21
+
22
+
**Goal:** Parse system fonts and rasterize glyphs without CoreText.
23
+
24
+
- OTF/TTF parser: read `cmap`, `glyf`, `loca`, `head`, `hhea`, `hmtx`, `maxp`, `OS/2`, `name` tables
25
+
- Glyph outline extraction (TrueType quadratic beziers)
26
+
- Rasterizer: scanline fill of glyph outlines to grayscale bitmaps
27
+
- Basic shaping: horizontal advance, kern table lookups
28
+
- Glyph cache (HashMap of rasterized bitmaps)
29
+
- Load fonts from `/System/Library/Fonts/` or `/Library/Fonts/`
30
+
31
+
## Phase 3: HTML Parsing + Basic DOM + Block Layout + Software Rendering
32
+
33
+
**Goal:** Parse HTML, build a DOM, do basic block layout, render text to the window.
34
+
35
+
- HTML5 tokenizer (per spec state machine)
36
+
- Tree builder (subset: `<html>`, `<head>`, `<body>`, `<p>`, `<h1>`–`<h6>`, `<div>`, `<span>`, `<a>`, `<br>`, `<pre>`, `<title>`, text nodes)
37
+
- DOM tree: `Document`, `Element`, `Text`, `Comment` node types
38
+
- Basic block layout: stack blocks vertically, wrap text into lines
39
+
- Software renderer: paint text glyphs and block backgrounds into CG bitmap
40
+
- Display painted bitmap in the AppKit window
41
+
42
+
**Test milestone:** Pass html5lib tokenizer tests.
43
+
44
+
## Phase 4: CSS Parsing + Selector Matching + Cascade + Inline/Text Layout
45
+
46
+
**Goal:** Parse CSS, match selectors, resolve styles, lay out inline content.
47
+
48
+
- CSS tokenizer (per spec)
49
+
- CSS parser: selectors, declarations, `@`-rules (at least `@media`, `@import`)
50
+
- Selector matching: type, class, ID, attribute, combinators (descendant, child, sibling)
51
+
- Cascade: origin, specificity, source order
52
+
- Computed style resolution
53
+
- Inline layout: inline boxes, line boxes, text wrapping, vertical alignment
54
+
- Handle `<style>` elements and `style` attributes
55
+
56
+
**Test milestone:** Pass Acid1.
57
+
58
+
## Phase 5: Pure Rust Crypto
59
+
60
+
**Goal:** Implement the cryptographic primitives needed for TLS 1.3.
61
+
62
+
- SHA-256, SHA-384, SHA-512 (FIPS 180-4)
63
+
- HMAC (RFC 2104)
64
+
- HKDF (RFC 5869)
65
+
- AES-128-GCM, AES-256-GCM (NIST SP 800-38D)
66
+
- ChaCha20-Poly1305 (RFC 8439)
67
+
- X25519 key exchange (RFC 7748)
68
+
- RSA PKCS#1 v1.5 signature verification (RFC 8017)
69
+
- ECDSA signature verification (P-256, P-384) (FIPS 186-4)
70
+
- ASN.1 DER parser
71
+
- X.509 certificate parsing and chain validation
72
+
73
+
## Phase 6: Pure Rust TLS 1.3 + TCP + DNS + HTTP/1.1 + URL Parser
74
+
75
+
**Goal:** Fetch resources over HTTPS.
76
+
77
+
- WHATWG URL parser (full spec compliance)
78
+
- DNS stub resolver (UDP, A/AAAA records, system resolver config)
79
+
- TCP socket wrapper (std::net)
80
+
- TLS 1.3 client (RFC 8446): handshake, record layer, key schedule, certificate verification
81
+
- HTTP/1.1 client: request/response parsing, chunked transfer encoding, keep-alive
82
+
- Connection pooling
83
+
- Content-Length and Transfer-Encoding handling
84
+
85
+
## Phase 7: Image Decoders
86
+
87
+
**Goal:** Decode common image formats in pure Rust.
88
+
89
+
- DEFLATE decompressor (RFC 1951)
90
+
- zlib wrapper (RFC 1950)
91
+
- PNG decoder (RFC 2083): IHDR, IDAT, PLTE, tRNS, interlacing
92
+
- JPEG decoder: baseline DCT, Huffman, JFIF/EXIF markers
93
+
- GIF decoder: LZW, frames, transparency
94
+
- Pixel format conversion (RGBA8)
95
+
96
+
## Phase 8: Resource Loading + Character Encoding + Real Page Loading
97
+
98
+
**Goal:** Load and render real web pages.
99
+
100
+
- WHATWG Encoding Standard: UTF-8, UTF-16, ISO-8859-1, Windows-1252, and other legacy encodings
101
+
- Encoding sniffing (BOM, HTTP header, meta tag, prescan)
102
+
- Resource loader: fetch HTML, CSS, images via `net` crate
103
+
- `<link rel="stylesheet">` and `<img>` loading
104
+
- Data URLs
105
+
- about:blank
106
+
107
+
## Phase 9: Advanced Layout
108
+
109
+
**Goal:** Handle modern CSS layout modes.
110
+
111
+
- Positioned layout: relative, absolute, fixed, sticky
112
+
- Flexbox (CSS Flexible Box Layout Level 1)
113
+
- Floats and clear
114
+
- Overflow and scrolling (scroll bars, `overflow: auto/scroll/hidden`)
115
+
- `display: none`, `visibility: hidden`
116
+
- `box-sizing`, margin collapsing
117
+
- Viewport units, percentage resolution
118
+
119
+
**Test milestone:** Pass Acid2.
120
+
121
+
## Phase 10: JavaScript Engine
122
+
123
+
**Goal:** Execute JavaScript with a JIT-ready architecture.
124
+
125
+
- Lexer/tokenizer (ECMAScript 2024)
126
+
- Parser → AST
127
+
- Bytecode compiler: register-based bytecode format designed for JIT
128
+
- Register-based VM: instruction dispatch, operand stack
129
+
- Garbage collector: tri-color mark-and-sweep
130
+
- Core built-ins: Object, Array, String, Number, Boolean, Function, Math, Date, RegExp, JSON, Error, Map, Set, Promise, Symbol
131
+
- `typeof`, `instanceof`, prototype chain, closures, `this` binding
132
+
- `var`/`let`/`const` scoping
133
+
- Iterators, generators, async/await
134
+
135
+
**Test milestone:** Pass Test262 core language subset.
136
+
137
+
## Phase 11: DOM-JS Bindings + Events + Timers + Fetch API
138
+
139
+
**Goal:** Connect JavaScript to the DOM and web APIs.
140
+
141
+
- DOM bindings: `document.getElementById`, `querySelector`, `createElement`, `appendChild`, `textContent`, `innerHTML`
142
+
- Event system: `addEventListener`, `removeEventListener`, `dispatchEvent`, bubbling/capturing
143
+
- `setTimeout`, `setInterval`, `requestAnimationFrame`
144
+
- Fetch API (backed by `net` crate)
145
+
- Console API (`console.log`, `console.error`, `console.warn`)
146
+
- `<script>` element loading and execution (defer, async)
147
+
148
+
**Test milestone:** Begin WPT pass rate tracking.
149
+
150
+
## Phase 12: Metal GPU Compositor
151
+
152
+
**Goal:** GPU-accelerated rendering.
153
+
154
+
- Metal device/command queue setup via `platform` crate
155
+
- Texture atlas for glyph cache
156
+
- Display list → Metal render passes
157
+
- Compositing layers (for transforms, opacity, will-change)
158
+
- Double-buffered presentation
159
+
- Fallback to software rendering when Metal unavailable
160
+
161
+
## Phase 13: Advanced CSS
162
+
163
+
**Goal:** Modern CSS features.
164
+
165
+
- CSS Grid Layout (Level 1)
166
+
- CSS Animations (`@keyframes`, `animation-*`)
167
+
- CSS Transitions (`transition-*`)
168
+
- CSS Custom Properties (`--var`, `var()`)
169
+
- `@font-face` (load and parse web fonts via `text` + `net`)
170
+
- `calc()`, `min()`, `max()`, `clamp()`
171
+
- Media queries (screen width, prefers-color-scheme)
172
+
- SVG basics: `<svg>`, `<rect>`, `<circle>`, `<path>`, `<text>`
173
+
174
+
## Phase 14: Security + Storage
175
+
176
+
**Goal:** Web security model and client-side storage.
177
+
178
+
- Same-Origin Policy enforcement
179
+
- CORS (preflight, simple requests, credentialed requests)
180
+
- Content Security Policy (CSP Level 2)
181
+
- Cookie jar (`Set-Cookie` parsing, `Cookie` header, SameSite, Secure, HttpOnly)
182
+
- `localStorage` / `sessionStorage`
183
+
- IndexedDB (basic subset)
184
+
- `<iframe>` isolation and `postMessage`
185
+
- Referrer Policy
186
+
187
+
## Phase 15: Performance
188
+
189
+
**Goal:** Production-grade performance.
190
+
191
+
- Baseline JIT compiler: bytecode → AArch64 machine code
192
+
- Inline caches for property access
193
+
- Incremental layout (dirty bit propagation)
194
+
- HTTP/2 (HPACK, multiplexed streams, flow control)
195
+
- Speculative HTML parsing (off-main-thread tokenization)
196
+
- Style sharing cache
197
+
- Layer tree and damage tracking for minimal repaints
198
+
- Memory profiling and optimization pass
199
+
200
+
---
201
+
202
+
## Test Suites
203
+
204
+
| Suite | Crate(s) | Phase |
205
+
|-------|----------|-------|
206
+
| html5lib-tests (tokenizer) | `html` | 3 |
207
+
| Acid1 | `css`, `style`, `layout`, `render` | 4 |
208
+
| Acid2 | `layout`, `render` | 9 |
209
+
| Test262 (core language) | `js` | 10 |
210
+
| WPT (progressive) | all | 11+ |
+19
README.md
+19
README.md
···
1
+
# we
2
+
3
+
A web browser engine written from scratch in pure Rust. macOS ARM only.
4
+
5
+
Zero external crate dependencies. Pure Rust for everything — crypto, TLS, font parsing, image decoding, JavaScript engine.
6
+
7
+
## Build
8
+
9
+
cargo build --workspace
10
+
11
+
## Run
12
+
13
+
cargo run -p we-browser
14
+
15
+
Requires: Rust toolchain, macOS on Apple Silicon.
16
+
17
+
## Test
18
+
19
+
cargo test --workspace
+27
crates/browser/Cargo.toml
+27
crates/browser/Cargo.toml
···
1
+
[package]
2
+
name = "we-browser"
3
+
version = "0.1.0"
4
+
edition.workspace = true
5
+
6
+
[[bin]]
7
+
name = "browser"
8
+
path = "src/main.rs"
9
+
10
+
[lib]
11
+
name = "we_browser"
12
+
path = "src/lib.rs"
13
+
14
+
[dependencies]
15
+
we-platform = { path = "../platform" }
16
+
we-net = { path = "../net" }
17
+
we-html = { path = "../html" }
18
+
we-css = { path = "../css" }
19
+
we-dom = { path = "../dom" }
20
+
we-style = { path = "../style" }
21
+
we-layout = { path = "../layout" }
22
+
we-text = { path = "../text" }
23
+
we-render = { path = "../render" }
24
+
we-js = { path = "../js" }
25
+
we-url = { path = "../url" }
26
+
we-encoding = { path = "../encoding" }
27
+
we-image = { path = "../image" }
+1
crates/browser/src/lib.rs
+1
crates/browser/src/lib.rs
···
1
+
//! Event loop, resource loading, navigation, UI chrome.
+8
crates/crypto/Cargo.toml
+8
crates/crypto/Cargo.toml
+1
crates/crypto/src/lib.rs
+1
crates/crypto/src/lib.rs
···
1
+
//! Pure Rust cryptography — AES-GCM, ChaCha20-Poly1305, SHA-2, X25519, RSA, X.509, ASN.1.
+8
crates/css/Cargo.toml
+8
crates/css/Cargo.toml
+1
crates/css/src/lib.rs
+1
crates/css/src/lib.rs
···
1
+
//! CSS tokenizer, parser, and CSSOM.
+8
crates/dom/Cargo.toml
+8
crates/dom/Cargo.toml
+1
crates/dom/src/lib.rs
+1
crates/dom/src/lib.rs
···
1
+
//! DOM tree, nodes, and events.
+8
crates/encoding/Cargo.toml
+8
crates/encoding/Cargo.toml
+1
crates/encoding/src/lib.rs
+1
crates/encoding/src/lib.rs
···
1
+
//! WHATWG Encoding Standard — all encodings, pure Rust.
+12
crates/html/Cargo.toml
+12
crates/html/Cargo.toml
+1
crates/html/src/lib.rs
+1
crates/html/src/lib.rs
···
1
+
//! HTML5 tokenizer and tree builder.
+8
crates/image/Cargo.toml
+8
crates/image/Cargo.toml
+1
crates/image/src/lib.rs
+1
crates/image/src/lib.rs
···
1
+
//! Image decoders — PNG (DEFLATE), JPEG, GIF, WebP — pure Rust.
+11
crates/js/Cargo.toml
+11
crates/js/Cargo.toml
+1
crates/js/src/lib.rs
+1
crates/js/src/lib.rs
···
1
+
//! JavaScript engine — lexer, parser, bytecode, register VM, GC, JIT (AArch64).
+14
crates/layout/Cargo.toml
+14
crates/layout/Cargo.toml
···
1
+
[package]
2
+
name = "we-layout"
3
+
version = "0.1.0"
4
+
edition.workspace = true
5
+
6
+
[lib]
7
+
name = "we_layout"
8
+
path = "src/lib.rs"
9
+
10
+
[dependencies]
11
+
we-dom = { path = "../dom" }
12
+
we-style = { path = "../style" }
13
+
we-css = { path = "../css" }
14
+
we-text = { path = "../text" }
+1
crates/layout/src/lib.rs
+1
crates/layout/src/lib.rs
···
1
+
//! Box generation, block/inline/flex/grid/table layout.
+12
crates/net/Cargo.toml
+12
crates/net/Cargo.toml
+1
crates/net/src/lib.rs
+1
crates/net/src/lib.rs
···
1
+
//! TCP, DNS, pure-Rust TLS 1.3, HTTP/1.1, HTTP/2.
+8
crates/platform/Cargo.toml
+8
crates/platform/Cargo.toml
+1
crates/platform/src/lib.rs
+1
crates/platform/src/lib.rs
···
1
+
//! Minimal macOS platform layer — Obj-C FFI, AppKit, CoreGraphics, Metal.
+16
crates/render/Cargo.toml
+16
crates/render/Cargo.toml
···
1
+
[package]
2
+
name = "we-render"
3
+
version = "0.1.0"
4
+
edition.workspace = true
5
+
6
+
[lib]
7
+
name = "we_render"
8
+
path = "src/lib.rs"
9
+
10
+
[dependencies]
11
+
we-platform = { path = "../platform" }
12
+
we-layout = { path = "../layout" }
13
+
we-dom = { path = "../dom" }
14
+
we-css = { path = "../css" }
15
+
we-text = { path = "../text" }
16
+
we-image = { path = "../image" }
+1
crates/render/src/lib.rs
+1
crates/render/src/lib.rs
···
1
+
//! Display list, software rasterizer, Metal GPU compositor.
+12
crates/style/Cargo.toml
+12
crates/style/Cargo.toml
+1
crates/style/src/lib.rs
+1
crates/style/src/lib.rs
···
1
+
//! Selector matching and computed style resolution.
+8
crates/text/Cargo.toml
+8
crates/text/Cargo.toml
+1
crates/text/src/lib.rs
+1
crates/text/src/lib.rs
···
1
+
//! Font parsing (OTF/TTF), shaping, rasterization, and line breaking — pure Rust.
+11
crates/url/Cargo.toml
+11
crates/url/Cargo.toml
+1
crates/url/src/lib.rs
+1
crates/url/src/lib.rs
···
1
+
//! WHATWG URL parser.