diff --git a/crates/browser/src/main.rs b/crates/browser/src/main.rs
index d821388..2fe4ad6 100644
--- a/crates/browser/src/main.rs
+++ b/crates/browser/src/main.rs
@@ -1,19 +1,37 @@
 use std::cell::RefCell;
 use std::collections::HashMap;
 
-use we_browser::loader::{ResourceLoader, ABOUT_BLANK_HTML};
+use we_browser::css_loader::collect_stylesheets;
+use we_browser::img_loader::{collect_images, ImageStore};
+use we_browser::loader::{Resource, ResourceLoader, ABOUT_BLANK_HTML};
+use we_css::parser::Stylesheet;
+use we_dom::{Document, NodeId};
 use we_html::parse_html;
+use we_image::pixel::Image;
 use we_layout::layout;
 use we_platform::appkit;
 use we_platform::cg::BitmapContext;
 use we_render::Renderer;
-use we_style::computed::{extract_stylesheets, resolve_styles};
+use we_style::computed::resolve_styles;
 use we_text::font::{self, Font};
+use we_url::Url;
+
+// ---------------------------------------------------------------------------
+// Page state: holds everything needed to re-render without re-fetching
+// ---------------------------------------------------------------------------
+
+/// Pre-fetched page data. Stored so that window resizes only re-style,
+/// re-layout, and re-render — no network requests.
+struct PageState {
+    doc: Document,
+    stylesheet: Stylesheet,
+    images: ImageStore,
+}
 
 /// Browser state kept in thread-local storage so the resize handler can
 /// access it. All AppKit callbacks run on the main thread.
 struct BrowserState {
-    html: String,
+    page: PageState,
     font: Font,
     bitmap: Box<BitmapContext>,
     view: appkit::BitmapView,
@@ -23,36 +41,65 @@ thread_local! {
     static STATE: RefCell<Option<BrowserState>> = const { RefCell::new(None) };
 }
 
-/// Re-run the full pipeline: parse → extract CSS → resolve styles → layout → render → copy to bitmap.
-fn render_page(html: &str, font: &Font, bitmap: &mut BitmapContext) {
+// ---------------------------------------------------------------------------
+// Rendering pipeline
+// ---------------------------------------------------------------------------
+
+/// Build a `HashMap<NodeId, (f32, f32)>` of display dimensions for layout.
+fn image_sizes(store: &ImageStore) -> HashMap<NodeId, (f32, f32)> {
+    let mut sizes = HashMap::new();
+    for (node_id, res) in store {
+        if res.display_width > 0.0 || res.display_height > 0.0 {
+            sizes.insert(*node_id, (res.display_width, res.display_height));
+        }
+    }
+    sizes
+}
+
+/// Build a `HashMap<NodeId, &Image>` reference map for the renderer.
+fn image_refs(store: &ImageStore) -> HashMap<NodeId, &Image> {
+    let mut refs = HashMap::new();
+    for (node_id, res) in store {
+        if let Some(ref img) = res.image {
+            refs.insert(*node_id, img);
+        }
+    }
+    refs
+}
+
+/// Re-run the pipeline: resolve styles → layout → render → copy to bitmap.
+///
+/// Uses pre-fetched `PageState` so no network I/O happens here.
+fn render_page(page: &PageState, font: &Font, bitmap: &mut BitmapContext) {
     let width = bitmap.width() as u32;
     let height = bitmap.height() as u32;
     if width == 0 || height == 0 {
         return;
     }
 
-    // Parse HTML into DOM.
-    let doc = parse_html(html);
-
-    // Extract CSS from <style> elements and resolve computed styles.
-    let stylesheets = extract_stylesheets(&doc);
-    let styled = match resolve_styles(&doc, &stylesheets) {
+    // Resolve computed styles from DOM + stylesheet.
+    let styled = match resolve_styles(&page.doc, std::slice::from_ref(&page.stylesheet)) {
         Some(s) => s,
         None => return,
     };
 
-    // Layout using styled tree (CSS-driven).
+    // Build image maps for layout (sizes) and render (pixel data).
+    let sizes = image_sizes(&page.images);
+    let refs = image_refs(&page.images);
+
+    // Layout.
     let tree = layout(
         &styled,
-        &doc,
+        &page.doc,
         width as f32,
         height as f32,
         font,
-        &HashMap::new(),
+        &sizes,
     );
 
+    // Render.
     let mut renderer = Renderer::new(width, height);
-    renderer.paint(&tree, font, &HashMap::new());
+    renderer.paint(&tree, font, &refs);
 
     // Copy rendered pixels into the bitmap context's buffer.
     let src = renderer.pixels();
@@ -82,7 +129,7 @@ fn handle_resize(width: f64, height: f64) {
             None => return,
         };
 
-        render_page(&state.html, &state.font, &mut new_bitmap);
+        render_page(&state.page, &state.font, &mut new_bitmap);
 
         // Swap in the new bitmap and update the view's pointer.
         state.bitmap = new_bitmap;
@@ -90,11 +137,22 @@ fn handle_resize(width: f64, height: f64) {
     });
 }
 
+// ---------------------------------------------------------------------------
+// Page loading
+// ---------------------------------------------------------------------------
+
+/// Result of loading a page: HTML text + base URL for resolving subresources.
+struct LoadedHtml {
+    text: String,
+    base_url: Url,
+}
+
 /// Load content from a command-line argument.
 ///
 /// Tries the argument as a URL first (http://, https://, about:, data:),
-/// then falls back to reading it as a file path.
-fn load_from_arg(arg: &str) -> String {
+/// then falls back to reading it as a local file.
+/// On failure, returns an error page instead of exiting.
+fn load_from_arg(arg: &str) -> LoadedHtml {
     // Try as URL if it has a recognized scheme.
     if arg.starts_with("http://")
         || arg.starts_with("https://")
@@ -103,35 +161,96 @@ fn load_from_arg(arg: &str) -> String {
     {
         let mut loader = ResourceLoader::new();
         match loader.fetch_url(arg, None) {
-            Ok(we_browser::loader::Resource::Html { text, .. }) => return text,
+            Ok(Resource::Html { text, base_url, .. }) => {
+                return LoadedHtml { text, base_url };
+            }
             Ok(_) => {
-                eprintln!("URL did not return HTML: {arg}");
-                std::process::exit(1);
+                return error_page(&format!("URL did not return HTML: {arg}"));
             }
             Err(e) => {
-                eprintln!("Error loading {arg}: {e}");
-                std::process::exit(1);
+                return error_page(&format!("Failed to load {arg}: {e}"));
             }
         }
     }
 
     // Fall back to file path.
     match std::fs::read_to_string(arg) {
-        Ok(content) => content,
-        Err(e) => {
-            eprintln!("Error reading {arg}: {e}");
-            std::process::exit(1);
+        Ok(content) => {
+            // Use a file:// base URL for resolving relative paths.
+            let abs_path =
+                std::fs::canonicalize(arg).unwrap_or_else(|_| std::path::PathBuf::from(arg));
+            let base_str = format!("file://{}", abs_path.display());
+            let base_url = Url::parse(&base_str).unwrap_or_else(|_| {
+                Url::parse("about:blank").expect("about:blank is always valid")
+            });
+            LoadedHtml {
+                text: content,
+                base_url,
+            }
         }
+        Err(e) => error_page(&format!("Error reading {arg}: {e}")),
+    }
+}
+
+/// Generate an HTML error page for display.
+fn error_page(message: &str) -> LoadedHtml {
+    eprintln!("{message}");
+    let escaped = message
+        .replace('&', "&amp;")
+        .replace('<', "&lt;")
+        .replace('>', "&gt;");
+    let html = format!(
+        "<!DOCTYPE html>\
+         <html><head><title>Error</title>\
+         <style>\
+         body {{ font-family: sans-serif; margin: 40px; color: #333; }}\
+         h1 {{ color: #c00; }}\
+         p {{ font-size: 16px; }}\
+         </style></head>\
+         <body><h1>Error</h1><p>{escaped}</p></body></html>"
+    );
+    let base_url = Url::parse("about:blank").expect("about:blank is always valid");
+    LoadedHtml {
+        text: html,
+        base_url,
     }
 }
 
+/// Load a page: fetch HTML, parse DOM, collect CSS and images.
+fn load_page(loaded: LoadedHtml) -> PageState {
+    let doc = parse_html(&loaded.text);
+
+    // Fetch external stylesheets and merge with inline <style> elements.
+    let mut loader = ResourceLoader::new();
+    let stylesheet = collect_stylesheets(&doc, &mut loader, &loaded.base_url);
+
+    // Fetch and decode images referenced by <img> elements.
+    let images = collect_images(&doc, &mut loader, &loaded.base_url);
+
+    PageState {
+        doc,
+        stylesheet,
+        images,
+    }
+}
+
+// ---------------------------------------------------------------------------
+// Entry point
+// ---------------------------------------------------------------------------
+
 fn main() {
-    // Load HTML from argument (URL, file path) or default to about:blank.
-    let html = match std::env::args().nth(1) {
+    // Load page from argument (URL, file path) or default to about:blank.
+    let loaded = match std::env::args().nth(1) {
         Some(arg) => load_from_arg(&arg),
-        None => ABOUT_BLANK_HTML.to_string(),
+        None => LoadedHtml {
+            text: ABOUT_BLANK_HTML.to_string(),
+            base_url: Url::parse("about:blank").expect("about:blank is always valid"),
+        },
     };
 
+    // Parse DOM and fetch subresources (CSS, images).
+    let page = load_page(loaded);
+
     // Load a system font for text rendering.
     let font = match font::load_system_font() {
         Ok(f) => f,
@@ -154,7 +273,7 @@ fn main() {
     // Initial render at the default window size (800x600).
     let mut bitmap =
         Box::new(BitmapContext::new(800, 600).expect("failed to create bitmap context"));
-    render_page(&html, &font, &mut bitmap);
+    render_page(&page, &font, &mut bitmap);
 
     // Create the view backed by the rendered bitmap.
     let frame = appkit::NSRect::new(0.0, 0.0, 800.0, 600.0);
@@ -164,7 +283,7 @@ fn main() {
     // Store state for the resize handler.
     STATE.with(|state| {
         *state.borrow_mut() = Some(BrowserState {
-            html,
+            page,
             font,
             bitmap,
             view,