diff --git a/CLAUDE.md b/CLAUDE.md
index 6253115..e5c0529 100644
--- a/CLAUDE.md
+++ b/CLAUDE.md
@@ -196,6 +196,62 @@ Prong uses a **hierarchical event propagation model** where events flow through
 
 Components must be enabled and visible to receive events. The Scene is the entry point for all events from the window system.
 
+### Resize Behavior
+
+Components can specify how they respond to parent resize events through resize behaviors. This is essential for responsive UI layouts.
+
+#### Unified Resize Behavior
+
+The `ResizeBehavior` enum provides unified control over both axes:
+- `FIXED`: Keep original size and position (default)
+- `SCALE`: Scale proportionally with parent
+- `FILL`: Fill available parent space
+- `MAINTAIN_ASPECT`: Scale while maintaining aspect ratio
+
+```cpp
+component->setResizeBehavior(Component::ResizeBehavior::FILL);
+```
+
+#### Per-Axis Resize Behavior
+
+For more control, use `AxisResizeBehavior` to set independent horizontal and vertical behavior:
+- `AxisResizeBehavior::FIXED`: Keep original size on this axis
+- `AxisResizeBehavior::SCALE`: Scale proportionally with parent on this axis
+- `AxisResizeBehavior::FILL`: Fill available parent space on this axis
+
+```cpp
+// Fixed width, fill height (common for panels in horizontal FlexLayout)
+panel->setAxisResizeBehavior(Component::AxisResizeBehavior::FIXED,
+                             Component::AxisResizeBehavior::FILL);
+```
+
+**Important**: When using FlexLayout, per-axis behavior is usually preferred:
+- For horizontal FlexLayout (ROW): Use `FIXED` or `SCALE` horizontally (let FlexLayout control width), `FILL` vertically
+- For vertical FlexLayout (COLUMN): Use `FILL` horizontally, `FIXED` or `SCALE` vertically (let FlexLayout control height)
+
+Example from demo app:
+```cpp
+// Left panel in horizontal FlexLayout: fixed width (200px), fills height
+leftPanel->setAxisResizeBehavior(Component::AxisResizeBehavior::FIXED,
+                                 Component::AxisResizeBehavior::FILL);
+
+// Center panel: fills both dimensions (grows with FlexLayout)
+centerPanel->setAxisResizeBehavior(Component::AxisResizeBehavior::FILL,
+                                   Component::AxisResizeBehavior::FILL);
+```
+
+#### Responsive Constraints
+
+Combine resize behavior with constraints for bounded resizing:
+```cpp
+Component::ResponsiveConstraints constraints;
+constraints.minWidth = 200;
+constraints.maxWidth = 600;
+constraints.minHeight = 150;
+constraints.maxHeight = 450;
+component->setConstraints(constraints);
+```
+
 ### Layout System
 
 Layout managers (`include/bombfork/prong/layout/`) use CRTP and provide:
@@ -331,7 +387,7 @@ The namespace for the installed target is `bombfork::prong`.
 - **Focus model**: Components track their own focus state via `FocusState` enum; Scene manages global focus
 - **Thread safety**: ThemeManager is thread-safe; other components assume single-threaded use
 - Always use the `mise build` command to build the library, tests and examples.
-- The demo app located in @examples/simple_app/ is used to test the library's UX, it is built and run with the `mise demo` command. It is meant to gather feedback from the user, and for overall feature validation.
+- The demo app located in @examples/demo_app/ is used to test the library's UX, it is built and run with the `mise demo` command. It is meant to gather feedback from the user, and for overall feature validation.
 - Use gh cli to interact with the github repo when needed
 - ALWAYS use ninja generator when using cmake.
 - NEVER bypass iwyu or clang-format
diff --git a/examples/demo_app/scenes/demo_scene.h b/examples/demo_app/scenes/demo_scene.h
index 91070bb..c6ddcf0 100644
--- a/examples/demo_app/scenes/demo_scene.h
+++ b/examples/demo_app/scenes/demo_scene.h
@@ -76,7 +76,6 @@ class StatusLabel : public Component {
 
     // Calculate baseline Y position
     // Text baseline needs to be positioned so the text appears centered in the component
-    // For a 24px font in a 30px component, baseline at +18 from top works well
     int baselineY = gy;
 
     renderer->drawText(text_.c_str(), gx + 10, baselineY, textColor_.r, textColor_.g, textColor_.b, textColor_.a);
@@ -125,8 +124,8 @@ class DemoScene : public Scene {
     lastDeltaTime = deltaTime;
     lastFpsUpdateTime += deltaTime;
 
-    // Update FPS counter every 0.1 seconds
-    if (lastFpsUpdateTime >= 0.1 && fpsLabelPtr) {
+    // Update FPS counter every 1 seconds
+    if (lastFpsUpdateTime >= 1 && fpsLabelPtr) {
       int fps = static_cast<int>(std::round(1.0 / deltaTime));
       fpsLabelPtr->setText("FPS: " + std::to_string(fps));
       lastFpsUpdateTime = 0.0;
@@ -223,10 +222,10 @@ class DemoScene : public Scene {
     // Create GLFW adapters for TextInput
     adapters = examples::glfw::GLFWAdapters::create(glfwWindow);
 
-    // === Main Layout - FlexLayout Horizontal ===
+    // === Main Layout - FlexLayout Vertical ===
     auto mainLayout = std::make_shared<FlexLayout>();
     mainLayout->configure(FlexLayout::Configuration{
-      .direction = FlexDirection::ROW, .justify = FlexJustify::START, .align = FlexAlign::STRETCH, .gap = 15.0f});
+      .direction = FlexDirection::ROW, .justify = FlexJustify::START, .align = FlexAlign::STRETCH, .gap = 3.0f});
 
     // Set flex item properties: left and right panels fixed width, center panel grows to fill
     mainLayout->setItemProperties({
@@ -244,26 +243,29 @@ class DemoScene : public Scene {
     toolbarPanelLayout->configure(FlexLayout::Configuration{
       .direction = FlexDirection::ROW, .justify = FlexJustify::START, .align = FlexAlign::STRETCH, .gap = 0.0f});
 
-    auto toolbarPanel = create<FlexPanel>().withSize(0, 40).withLayout(toolbarPanelLayout).build();
-    toolbarPanel->setBackgroundColor(theming::Color(0.12f, 0.12f, 0.14f, 1.0f));
+    auto toolbarPanel = create<FlexPanel>().withSize(0, 35).withLayout(toolbarPanelLayout).build();
     toolbarPanel->setBorderColor(theming::Color(0.3f, 0.3f, 0.35f, 1.0f));
     toolbarPanel->setBorderWidth(1);
-    toolbarPanel->setPadding(5);
     toolbarPanel->addChild(std::move(toolbar));
 
     // === LEFT PANEL - Controls & Inputs ===
     auto leftPanel = buildControlPanel();
+    // Fixed width horizontally (controlled by FlexLayout grow/shrink=0), fill vertically
+    leftPanel->setAxisResizeBehavior(Component::AxisResizeBehavior::FIXED, Component::AxisResizeBehavior::FILL);
 
     // === CENTER PANEL - Layout Demonstrations ===
     auto centerPanel = buildCenterPanel();
+    // Fill horizontally (controlled by FlexLayout grow/shrink=1), fill vertically
+    centerPanel->setAxisResizeBehavior(Component::AxisResizeBehavior::FILL, Component::AxisResizeBehavior::FILL);
 
     // === RIGHT PANEL - Component Showcase ===
     auto rightPanel = buildComponentShowcase();
+    // Fixed width horizontally (controlled by FlexLayout grow/shrink=0), fill vertically
+    rightPanel->setAxisResizeBehavior(Component::AxisResizeBehavior::FIXED, Component::AxisResizeBehavior::FILL);
 
     // === Assemble 3-panel layout with FlexLayout ===
     auto threePanelContainer = create<FlexPanel>().withLayout(mainLayout).build();
     threePanelContainer->setBackgroundColor(theming::Color(0.08f, 0.08f, 0.1f, 1.0f));
-    threePanelContainer->setPadding(15);
 
     threePanelContainer->addChild(std::move(leftPanel));
     threePanelContainer->addChild(std::move(centerPanel));
@@ -280,7 +282,6 @@ class DemoScene : public Scene {
     statusBarPanel->setBackgroundColor(theming::Color(0.1f, 0.1f, 0.12f, 1.0f));
     statusBarPanel->setBorderColor(theming::Color(0.3f, 0.3f, 0.35f, 1.0f));
     statusBarPanel->setBorderWidth(1);
-    statusBarPanel->setPadding(5);
 
     // Left status label
     auto appNameLabel = std::make_unique<StatusLabel>("Prong UI Framework - Scene Demo");
@@ -315,9 +316,10 @@ class DemoScene : public Scene {
     // Add root container to scene
     addChild(std::move(rootContainer));
 
-    // Initialize main container size to match scene/window
+    // Initialize main container size to match scene/window and set it to FILL behavior
     if (!children.empty() && children[0]) {
       children[0]->setBounds(0, 0, width, height);
+      children[0]->setResizeBehavior(Component::ResizeBehavior::FILL);
       children[0]->invalidateLayout();
     }
 
@@ -336,20 +338,19 @@ class DemoScene : public Scene {
   std::unique_ptr<FlexPanel> buildControlPanel() {
     auto leftLayout = std::make_shared<FlexLayout>();
     leftLayout->configure(FlexLayout::Configuration{
-      .direction = FlexDirection::COLUMN, .justify = FlexJustify::START, .align = FlexAlign::STRETCH, .gap = 10.0f});
-
-    auto leftPanel = create<FlexPanel>().withSize(280, 0).withLayout(leftLayout).build();
+      .direction = FlexDirection::COLUMN, .justify = FlexJustify::START, .align = FlexAlign::STRETCH, .gap = 1.0f});
 
+    auto leftPanel = create<FlexPanel>().withSize(300, 0).withLayout(leftLayout).build();
     leftPanel->setBackgroundColor(theming::Color(0.15f, 0.15f, 0.18f, 1.0f));
     leftPanel->setBorderColor(theming::Color(0.3f, 0.3f, 0.35f, 1.0f));
     leftPanel->setBorderWidth(2);
     leftPanel->setTitle("Controls");
-    leftPanel->setPadding(15);
 
     // === TextInput Demo ===
     auto textInput =
       create<TextInput>()
         .withPlaceholder("Enter text here...")
+        .withSize(0, 30)
         .withTextChangedCallback([](const std::string& text) { std::cout << "Text: " << text << std::endl; })
         .build();
     textInputPtr = textInput.get();
@@ -363,7 +364,7 @@ class DemoScene : public Scene {
     buttonRowLayout->configure(FlexLayout::Configuration{.direction = FlexDirection::ROW,
                                                          .justify = FlexJustify::SPACE_BETWEEN,
                                                          .align = FlexAlign::STRETCH,
-                                                         .gap = 10.0f});
+                                                         .gap = 1.0f});
 
     auto buttonRow = create<FlexPanel>().withLayout(buttonRowLayout).build();
     buttonRow->setBackgroundColor(theming::Color(0.0f, 0.0f, 0.0f, 0.0f));
@@ -452,7 +453,6 @@ class DemoScene : public Scene {
     centerPanel->setBorderColor(theming::Color(0.3f, 0.3f, 0.35f, 1.0f));
     centerPanel->setBorderWidth(2);
     centerPanel->setTitle("Layout Demonstrations");
-    centerPanel->setPadding(15);
 
     // === GridLayout Demo ===
     auto gridPanel = buildGridLayoutDemo();
@@ -495,7 +495,6 @@ class DemoScene : public Scene {
     gridPanel->setBorderColor(theming::Color(0.3f, 0.3f, 0.35f, 1.0f));
     gridPanel->setBorderWidth(1);
     gridPanel->setTitle("GridLayout (3x3 Button Grid)");
-    gridPanel->setPadding(10);
 
     // Add 9 buttons in 3x3 grid
     for (int i = 1; i <= 9; ++i) {
@@ -526,7 +525,6 @@ class DemoScene : public Scene {
     flowPanel->setBorderColor(theming::Color(0.3f, 0.3f, 0.35f, 1.0f));
     flowPanel->setBorderWidth(1);
     flowPanel->setTitle("FlowLayout (Tag-like Interface)");
-    flowPanel->setPadding(10);
 
     // Add various-sized "tag" buttons
     std::vector<std::string> tags = {"C++20", "UI",        "Framework",   "Modern",
@@ -558,7 +556,6 @@ class DemoScene : public Scene {
     stackPanel->setBorderColor(theming::Color(0.3f, 0.3f, 0.35f, 1.0f));
     stackPanel->setBorderWidth(1);
     stackPanel->setTitle("StackLayout (Horizontal Stack)");
-    stackPanel->setPadding(10);
     stackPanel->setLayoutManager(stackLayout);
 
     // Add horizontally stacked buttons
@@ -586,7 +583,6 @@ class DemoScene : public Scene {
     wrapperPanel->setBorderColor(theming::Color(0.3f, 0.3f, 0.35f, 1.0f));
     wrapperPanel->setBorderWidth(1);
     wrapperPanel->setTitle("DockLayout (Application-style Panel Docking)");
-    wrapperPanel->setPadding(10);
 
     // Create DockLayout
     auto dockLayout = std::make_shared<DockLayout>();
@@ -606,7 +602,6 @@ class DemoScene : public Scene {
     leftPanel->setBorderColor(theming::Color(0.4f, 0.5f, 0.6f, 1.0f));
     leftPanel->setBorderWidth(1);
     leftPanel->setTitle("Files");
-    leftPanel->setPadding(5);
 
     // Add file browser-style buttons
     auto fileLayout = std::make_shared<StackLayout>();
@@ -630,7 +625,6 @@ class DemoScene : public Scene {
     topPanel->setBorderColor(theming::Color(0.5f, 0.4f, 0.6f, 1.0f));
     topPanel->setBorderWidth(1);
     topPanel->setTitle("Tools");
-    topPanel->setPadding(5);
 
     // Add horizontal tool buttons
     auto toolLayout = std::make_shared<StackLayout>();
@@ -649,11 +643,11 @@ class DemoScene : public Scene {
 
     // === RIGHT DOCK - Properties Style ===
     auto rightPanel = create<Panel<>>().withSize(0, 0).build();
+
     rightPanel->setBackgroundColor(theming::Color(0.3f, 0.25f, 0.2f, 1.0f));
     rightPanel->setBorderColor(theming::Color(0.6f, 0.5f, 0.4f, 1.0f));
     rightPanel->setBorderWidth(1);
     rightPanel->setTitle("Properties");
-    rightPanel->setPadding(5);
 
     // Add property-style labels
     auto propLayout = std::make_shared<StackLayout>();
@@ -675,7 +669,6 @@ class DemoScene : public Scene {
     centerPanel->setBorderColor(theming::Color(0.3f, 0.3f, 0.3f, 1.0f));
     centerPanel->setBorderWidth(1);
     centerPanel->setTitle("Editor");
-    centerPanel->setPadding(5);
 
     // Add center content label
     auto centerLabel = create<Button>("Main content area - click docked panels to interact").build();
@@ -745,7 +738,6 @@ class DemoScene : public Scene {
     wrapperPanel->setBorderColor(theming::Color(0.3f, 0.3f, 0.35f, 1.0f));
     wrapperPanel->setBorderWidth(1);
     wrapperPanel->setTitle("Viewport (Scrollable Content with Pan & Zoom)");
-    wrapperPanel->setPadding(10);
 
     // Create viewport with fixed height to demonstrate scrolling
     // Width will be set by FlexLayout, only set height
@@ -763,8 +755,8 @@ class DemoScene : public Scene {
     // Create render callback with visible content
     // The callback receives viewportX/viewportY which is the viewport's global screen position
     // All rendering must be offset by viewportX/viewportY to appear within the viewport
-    viewport->setRenderCallback([this](rendering::IRenderer* rend, const Viewport::ViewportTransform& transform, int,
-                                       int, int viewportX, int viewportY) {
+    viewport->setRenderCallback([](rendering::IRenderer* rend, const Viewport::ViewportTransform& transform, int, int,
+                                   int viewportX, int viewportY) {
       // Draw a checkerboard pattern to show viewport boundaries
       // Content coordinates: (0,0) to (800,600) in content space
       // Transform: apply zoom and pan, then offset by viewport position
@@ -834,15 +826,14 @@ class DemoScene : public Scene {
   std::unique_ptr<FlexPanel> buildComponentShowcase() {
     auto rightLayout = std::make_shared<FlexLayout>();
     rightLayout->configure(FlexLayout::Configuration{
-      .direction = FlexDirection::COLUMN, .justify = FlexJustify::START, .align = FlexAlign::STRETCH, .gap = 10.0f});
+      .direction = FlexDirection::COLUMN, .justify = FlexJustify::START, .align = FlexAlign::STRETCH, .gap = 1.0f});
 
     auto rightPanel = create<FlexPanel>().withSize(320, 0).withLayout(rightLayout).build();
 
     rightPanel->setBackgroundColor(theming::Color(0.15f, 0.15f, 0.18f, 1.0f));
     rightPanel->setBorderColor(theming::Color(0.3f, 0.3f, 0.35f, 1.0f));
-    rightPanel->setBorderWidth(2);
+    rightPanel->setBorderWidth(1);
     rightPanel->setTitle("Component Showcase");
-    rightPanel->setPadding(15);
 
     // === ListBox Demo ===
     auto listBox = std::make_unique<ListBox>();
@@ -907,7 +898,7 @@ class DemoScene : public Scene {
     int helpId = toolbar->addTool("Help", "", "Show help documentation", "F1");
 
     // Set toolbar callback for actions
-    toolbar->setToolCallback([this, fileId, editId, viewId, helpId](int toolId) {
+    toolbar->setToolCallback([fileId, editId, viewId, helpId](int toolId) {
       if (toolId == fileId) {
         std::cout << "[Toolbar] File action triggered" << std::endl;
       } else if (toolId == editId) {
@@ -955,7 +946,6 @@ class DemoScene : public Scene {
 
     auto contentPanel = create<FlexPanel>().withLayout(contentLayout).build();
     contentPanel->setBackgroundColor(theming::Color(0.0f, 0.0f, 0.0f, 0.0f));
-    contentPanel->setPadding(20);
     contentPanel->setBounds(0, 40, 500, 310); // Below title bar, above button area
 
     // Add content text using buttons as labels (since we don't have a Label component)
@@ -1012,8 +1002,9 @@ class DemoScene : public Scene {
    * @brief Print welcome message
    */
   void printWelcomeMessage() {
-    std::cout << "\n╔══════════════════════════════════════════════════════════════╗" << std::endl;
-    std::cout << "║         Prong UI Framework - Comprehensive Demo             ║" << std::endl;
+    std::cout << std::endl;
+    std::cout << "╔══════════════════════════════════════════════════════════════╗" << std::endl;
+    std::cout << "║          Prong UI Framework - Comprehensive Demo             ║" << std::endl;
     std::cout << "╚══════════════════════════════════════════════════════════════╝" << std::endl;
     std::cout << "\nCore Components Demonstrated:" << std::endl;
     std::cout << "  * Button          - Interactive buttons with callbacks" << std::endl;
@@ -1040,20 +1031,24 @@ class DemoScene : public Scene {
     std::cout << "  • Click DockLayout panels (Files, Tools, Properties) to see docking behavior" << std::endl;
     std::cout << "  • Click any button to see console output" << std::endl;
     std::cout << "  • Select items in ListBox" << std::endl;
+    std::cout << "  • RESIZE the window to see automatic layout reflow!" << std::endl;
     std::cout << "  • ESC key or 'Exit Application' to close" << std::endl;
     std::cout << "\n══════════════════════════════════════════════════════════════\n" << std::endl;
   }
 
   /**
-   * @brief Handle window resize
+   * @brief Handle window resize - automatic propagation via Scene base class
    */
   void onWindowResize(int width, int height) override {
+    // Call base implementation which handles:
+    // 1. Update scene bounds
+    // 2. Invalidate layout
+    // 3. Notify renderer
+    // 4. Propagate resize to children (which triggers their ResizeBehavior)
     Scene::onWindowResize(width, height);
 
-    if (!children.empty() && children[0]) {
-      children[0]->setBounds(0, 0, width, height);
-      children[0]->invalidateLayout();
-    }
+    // No manual sizing needed - root container has FILL behavior set in buildUI()
+    // and will automatically resize to match the scene dimensions
   }
 };
 
diff --git a/include/bombfork/prong/components/panel.h b/include/bombfork/prong/components/panel.h
index 7cee00e..cb3bcb1 100644
--- a/include/bombfork/prong/components/panel.h
+++ b/include/bombfork/prong/components/panel.h
@@ -397,6 +397,53 @@ class Panel : public Component {
     }
   }
 
+  // === Resize Handling ===
+
+  /**
+   * @brief Handle parent resize events
+   *
+   * Panels can automatically fill parent or use standard resize behavior.
+   * This override checks for auto-fill first, then delegates to Component.
+   *
+   * @param parentWidth New parent width
+   * @param parentHeight New parent height
+   */
+  void onParentResize(int parentWidth, int parentHeight) override {
+    // If auto-fill is enabled, use FILL behavior regardless of setting
+    if (autoFillParent) {
+      // Try to get content bounds from parent if it's a Panel
+      Panel* parentPanel = dynamic_cast<Panel*>(parent);
+      if (parentPanel) {
+        int contentX, contentY, contentWidth, contentHeight;
+        parentPanel->getContentBounds(contentX, contentY, contentWidth, contentHeight);
+
+        // Convert parent's global content bounds to local coordinates
+        int parentGx, parentGy;
+        parent->getGlobalPosition(parentGx, parentGy);
+        int localContentX = contentX - parentGx;
+        int localContentY = contentY - parentGy;
+
+        setBounds(localContentX, localContentY, contentWidth, contentHeight);
+      } else {
+        // Parent is not a Panel, fill entire parent space
+        setBounds(0, 0, parentWidth, parentHeight);
+      }
+
+      // Mark layout as invalid to trigger re-layout
+      invalidateLayout();
+
+      // Propagate to children
+      for (auto& child : children) {
+        if (child) {
+          child->onParentResize(width, height);
+        }
+      }
+    } else {
+      // Use standard resize behavior from Component
+      Component::onParentResize(parentWidth, parentHeight);
+    }
+  }
+
   // === Update ===
 
   void update(double deltaTime) override {
diff --git a/include/bombfork/prong/core/component.h b/include/bombfork/prong/core/component.h
index 08c599d..423a4cb 100644
--- a/include/bombfork/prong/core/component.h
+++ b/include/bombfork/prong/core/component.h
@@ -4,6 +4,8 @@
 #include <bombfork/prong/layout/layout_manager.h>
 
 #include <algorithm>
+#include <climits>
+#include <cmath>
 #include <functional>
 #include <memory>
 #include <string>
@@ -40,6 +42,40 @@ class Component {
     ACTIVE    // Component is being interacted with
   };
 
+  /**
+   * @brief Resize behavior controls how component responds to parent resize
+   */
+  enum class ResizeBehavior {
+    FIXED,          // Keep original size and position
+    SCALE,          // Scale proportionally with parent
+    FILL,           // Fill available parent space
+    MAINTAIN_ASPECT // Scale while maintaining aspect ratio
+  };
+
+  /**
+   * @brief Per-axis resize behavior for independent horizontal/vertical control
+   */
+  enum class AxisResizeBehavior {
+    FIXED, // Keep original size on this axis
+    SCALE, // Scale proportionally with parent on this axis
+    FILL   // Fill available parent space on this axis
+  };
+
+  /**
+   * @brief Constraints for responsive sizing
+   */
+  struct ResponsiveConstraints {
+    int minWidth = 0;
+    int minHeight = 0;
+    int maxWidth = INT_MAX;
+    int maxHeight = INT_MAX;
+    float aspectRatio = 0.0f; // 0 = no constraint
+
+    ResponsiveConstraints() = default;
+    ResponsiveConstraints(int minW, int minH, int maxW = INT_MAX, int maxH = INT_MAX, float ar = 0.0f)
+      : minWidth(minW), minHeight(minH), maxWidth(maxW), maxHeight(maxH), aspectRatio(ar) {}
+  };
+
 public:
   // Renderer access
   bombfork::prong::rendering::IRenderer* renderer = nullptr;
@@ -83,6 +119,20 @@ class Component {
   FocusState focusState = FocusState::NONE;
   bool isCurrentlyHovered = false; // Track if mouse is currently over this component
 
+  // Resize handling
+  ResizeBehavior resizeBehavior = ResizeBehavior::FIXED;
+  AxisResizeBehavior horizontalResizeBehavior = AxisResizeBehavior::FIXED;
+  AxisResizeBehavior verticalResizeBehavior = AxisResizeBehavior::FIXED;
+  bool usePerAxisBehavior = false; // If true, use per-axis behaviors instead of resizeBehavior
+  ResponsiveConstraints constraints;
+  int originalParentWidth = 0;
+  int originalParentHeight = 0;
+  // Original component dimensions (for SCALE and MAINTAIN_ASPECT behaviors)
+  int originalLocalX = 0;
+  int originalLocalY = 0;
+  int originalWidth = 0;
+  int originalHeight = 0;
+
   // Parent/child relationships
   Component* parent = nullptr;
   std::vector<std::unique_ptr<Component>> children;
@@ -130,11 +180,68 @@ class Component {
    * @param newHeight Component height
    */
   virtual void setBounds(int newX, int newY, int newWidth, int newHeight) {
+    // If this component has per-axis resize behavior, apply it before setting bounds
+    // This allows components to resist unwanted size changes (e.g., FIXED axis)
+    if (usePerAxisBehavior && parent != nullptr) {
+      // Check if size would change
+      if (width != newWidth || height != newHeight) {
+        // Get parent size (our resize behavior is relative to parent)
+        int parentWidth, parentHeight;
+        parent->getSize(parentWidth, parentHeight);
+
+        // Apply per-axis behavior to determine actual size we should use
+        int adjustedWidth = newWidth;
+        int adjustedHeight = newHeight;
+
+        // Apply horizontal behavior
+        switch (horizontalResizeBehavior) {
+        case AxisResizeBehavior::FIXED:
+          // Keep original width, ignore requested width
+          adjustedWidth = (originalWidth > 0) ? originalWidth : width;
+          break;
+        case AxisResizeBehavior::SCALE:
+        case AxisResizeBehavior::FILL:
+          // Allow the requested width
+          adjustedWidth = newWidth;
+          break;
+        }
+
+        // Apply vertical behavior
+        switch (verticalResizeBehavior) {
+        case AxisResizeBehavior::FIXED:
+          // Keep original height, ignore requested height
+          adjustedHeight = (originalHeight > 0) ? originalHeight : height;
+          break;
+        case AxisResizeBehavior::SCALE:
+        case AxisResizeBehavior::FILL:
+          // Allow the requested height
+          adjustedHeight = newHeight;
+          break;
+        }
+
+        // Use adjusted sizes
+        newWidth = adjustedWidth;
+        newHeight = adjustedHeight;
+      }
+    }
+
+    // Check if size actually changed
+    bool sizeChanged = (width != newWidth || height != newHeight);
+
     localX = newX;
     localY = newY;
     width = newWidth;
     height = newHeight;
     invalidateGlobalCache();
+
+    // If size changed, notify children so they can apply their resize behavior
+    if (sizeChanged) {
+      for (auto& child : children) {
+        if (child) {
+          child->onParentResize(newWidth, newHeight);
+        }
+      }
+    }
   }
 
   /**
@@ -370,6 +477,242 @@ class Component {
 
   virtual bool canReceiveFocus() const { return enabled && visible; }
 
+  // === Resize Management ===
+
+  /**
+   * @brief Set resize behavior for this component
+   * @param behavior How component should respond to parent resize
+   */
+  void setResizeBehavior(ResizeBehavior behavior) {
+    resizeBehavior = behavior;
+    usePerAxisBehavior = false;
+  }
+
+  /**
+   * @brief Get current resize behavior
+   */
+  ResizeBehavior getResizeBehavior() const { return resizeBehavior; }
+
+  /**
+   * @brief Set per-axis resize behavior for independent horizontal/vertical control
+   * @param horizontal Resize behavior for horizontal axis
+   * @param vertical Resize behavior for vertical axis
+   */
+  void setAxisResizeBehavior(AxisResizeBehavior horizontal, AxisResizeBehavior vertical) {
+    horizontalResizeBehavior = horizontal;
+    verticalResizeBehavior = vertical;
+    usePerAxisBehavior = true;
+
+    // Initialize original dimensions NOW so FIXED behavior works from the start
+    // This captures the component's current size as the "original" before any layout runs
+    if (originalWidth == 0 && originalHeight == 0) {
+      originalLocalX = localX;
+      originalLocalY = localY;
+      originalWidth = width;
+      originalHeight = height;
+
+      // Also initialize parent dimensions if we have a parent
+      if (parent) {
+        parent->getSize(originalParentWidth, originalParentHeight);
+      }
+    }
+  }
+
+  /**
+   * @brief Get horizontal resize behavior
+   */
+  AxisResizeBehavior getHorizontalResizeBehavior() const { return horizontalResizeBehavior; }
+
+  /**
+   * @brief Get vertical resize behavior
+   */
+  AxisResizeBehavior getVerticalResizeBehavior() const { return verticalResizeBehavior; }
+
+  /**
+   * @brief Check if using per-axis resize behavior
+   */
+  bool isUsingPerAxisBehavior() const { return usePerAxisBehavior; }
+
+  /**
+   * @brief Set responsive constraints for sizing
+   * @param newConstraints Min/max size and aspect ratio constraints
+   */
+  void setConstraints(const ResponsiveConstraints& newConstraints) { constraints = newConstraints; }
+
+  /**
+   * @brief Get current constraints
+   */
+  const ResponsiveConstraints& getConstraints() const { return constraints; }
+
+  /**
+   * @brief Called when parent component is resized
+   *
+   * Override this to implement custom resize behavior. The default
+   * implementation uses the ResizeBehavior setting to automatically
+   * handle common resize patterns.
+   *
+   * @param parentWidth New parent width
+   * @param parentHeight New parent height
+   */
+  virtual void onParentResize(int parentWidth, int parentHeight) {
+    // Initialize original dimensions if not set (first resize call)
+    if (originalParentWidth == 0 && originalParentHeight == 0) {
+      originalParentWidth = parentWidth;
+      originalParentHeight = parentHeight;
+      // Store original component dimensions for SCALE and MAINTAIN_ASPECT
+      originalLocalX = localX;
+      originalLocalY = localY;
+      originalWidth = width;
+      originalHeight = height;
+    }
+
+    // Use per-axis behavior if enabled, otherwise use unified behavior
+    if (usePerAxisBehavior) {
+      applyPerAxisResize(parentWidth, parentHeight);
+    } else {
+      applyUnifiedResize(parentWidth, parentHeight);
+    }
+
+    // Apply constraints
+    applyConstraints();
+
+    // Mark layout as invalid to trigger re-layout
+    invalidateLayout();
+
+    // Note: We don't propagate to children here because setBounds() already
+    // handles propagation when the size actually changes. Propagating here
+    // would cause children to receive onParentResize() twice.
+  }
+
+protected:
+  /**
+   * @brief Apply unified resize behavior (original behavior)
+   */
+  void applyUnifiedResize(int parentWidth, int parentHeight) {
+    switch (resizeBehavior) {
+    case ResizeBehavior::FILL: {
+      // Fill available parent space
+      setBounds(0, 0, parentWidth, parentHeight);
+      break;
+    }
+    case ResizeBehavior::SCALE: {
+      // Scale proportionally from ORIGINAL dimensions
+      if (originalParentWidth > 0 && originalParentHeight > 0) {
+        float scaleX = parentWidth / static_cast<float>(originalParentWidth);
+        float scaleY = parentHeight / static_cast<float>(originalParentHeight);
+
+        // Scale from original dimensions, not current ones!
+        int newX = static_cast<int>(originalLocalX * scaleX);
+        int newY = static_cast<int>(originalLocalY * scaleY);
+        int newWidth = static_cast<int>(originalWidth * scaleX);
+        int newHeight = static_cast<int>(originalHeight * scaleY);
+
+        setBounds(newX, newY, newWidth, newHeight);
+      }
+      break;
+    }
+    case ResizeBehavior::MAINTAIN_ASPECT: {
+      // Scale while maintaining aspect ratio from ORIGINAL dimensions
+      if (originalParentWidth > 0 && originalParentHeight > 0 && originalWidth > 0 && originalHeight > 0) {
+        float currentAspect = originalWidth / static_cast<float>(originalHeight);
+        float scale = std::min(parentWidth / static_cast<float>(originalParentWidth),
+                               parentHeight / static_cast<float>(originalParentHeight));
+
+        int newWidth = static_cast<int>(originalWidth * scale);
+        int newHeight = static_cast<int>(newWidth / currentAspect);
+
+        // Center in available space
+        int newX = (parentWidth - newWidth) / 2;
+        int newY = (parentHeight - newHeight) / 2;
+
+        setBounds(newX, newY, newWidth, newHeight);
+      }
+      break;
+    }
+    case ResizeBehavior::FIXED:
+      // Do nothing - keep original size and position
+      break;
+    }
+  }
+
+  /**
+   * @brief Apply per-axis resize behavior for independent horizontal/vertical control
+   */
+  void applyPerAxisResize(int parentWidth, int parentHeight) {
+    int newX = localX;
+    int newY = localY;
+    int newWidth = width;
+    int newHeight = height;
+
+    // Calculate scale factors
+    float scaleX = (originalParentWidth > 0) ? parentWidth / static_cast<float>(originalParentWidth) : 1.0f;
+    float scaleY = (originalParentHeight > 0) ? parentHeight / static_cast<float>(originalParentHeight) : 1.0f;
+
+    // Apply horizontal behavior
+    switch (horizontalResizeBehavior) {
+    case AxisResizeBehavior::FILL:
+      newX = 0;
+      newWidth = parentWidth;
+      break;
+    case AxisResizeBehavior::SCALE:
+      newX = static_cast<int>(originalLocalX * scaleX);
+      newWidth = static_cast<int>(originalWidth * scaleX);
+      break;
+    case AxisResizeBehavior::FIXED:
+      // Keep original X and width
+      newX = originalLocalX;
+      newWidth = originalWidth;
+      break;
+    }
+
+    // Apply vertical behavior
+    switch (verticalResizeBehavior) {
+    case AxisResizeBehavior::FILL:
+      newY = 0;
+      newHeight = parentHeight;
+      break;
+    case AxisResizeBehavior::SCALE:
+      newY = static_cast<int>(originalLocalY * scaleY);
+      newHeight = static_cast<int>(originalHeight * scaleY);
+      break;
+    case AxisResizeBehavior::FIXED:
+      // Keep original Y and height
+      newY = originalLocalY;
+      newHeight = originalHeight;
+      break;
+    }
+
+    setBounds(newX, newY, newWidth, newHeight);
+  }
+
+  /**
+   * @brief Apply responsive constraints to current size
+   */
+  void applyConstraints() {
+    if (constraints.minWidth > 0 || constraints.maxWidth < INT_MAX || constraints.minHeight > 0 ||
+        constraints.maxHeight < INT_MAX || constraints.aspectRatio > 0.0f) {
+
+      int newWidth = width;
+      int newHeight = height;
+
+      // Apply min/max constraints
+      newWidth = std::clamp(newWidth, constraints.minWidth, constraints.maxWidth);
+      newHeight = std::clamp(newHeight, constraints.minHeight, constraints.maxHeight);
+
+      // Apply aspect ratio constraint
+      if (constraints.aspectRatio > 0.0f) {
+        newHeight = static_cast<int>(newWidth / constraints.aspectRatio);
+        // Re-check height constraints after aspect ratio adjustment
+        newHeight = std::clamp(newHeight, constraints.minHeight, constraints.maxHeight);
+      }
+
+      if (newWidth != width || newHeight != height) {
+        setSize(newWidth, newHeight);
+      }
+    }
+  }
+
+public:
   // === Parent/Child Management ===
 
   void addChild(std::unique_ptr<Component> child) {
diff --git a/include/bombfork/prong/core/scene.h b/include/bombfork/prong/core/scene.h
index 173e568..629745e 100644
--- a/include/bombfork/prong/core/scene.h
+++ b/include/bombfork/prong/core/scene.h
@@ -193,18 +193,19 @@ class Scene : public Component {
   /**
    * @brief Notify children of window resize
    *
-   * Children can override setBounds() to implement custom resize behavior.
+   * Calls onParentResize() on all children to trigger their resize behavior.
    *
    * @param width New window width
    * @param height New window height
    */
   void notifyChildrenOfResize(int width, int height) {
-    (void)width;  // Available for child components to use
-    (void)height; // Available for child components to use
-
-    // Children can override setBounds() to implement custom resize behavior.
-    // By default, children maintain their current position and size.
-    // For automatic layout, use Layout managers or override this method.
+    // Notify all children of the resize
+    // They will apply their ResizeBehavior and propagate to their children
+    for (auto& child : children) {
+      if (child) {
+        child->onParentResize(width, height);
+      }
+    }
   }
 };
 
diff --git a/tests/test_axis_resize.cpp b/tests/test_axis_resize.cpp
new file mode 100644
index 0000000..4b52a7b
--- /dev/null
+++ b/tests/test_axis_resize.cpp
@@ -0,0 +1,249 @@
+/**
+ * @file test_axis_resize.cpp
+ * @brief Unit tests for per-axis resize behavior
+ */
+
+#include <bombfork/prong/core/component.h>
+
+#include <cassert>
+#include <exception>
+#include <iostream>
+#include <memory>
+#include <string>
+#include <utility>
+
+using namespace bombfork::prong;
+
+// Simple concrete component for testing
+class TestComponent : public Component {
+public:
+  explicit TestComponent(const std::string& name = "TestComponent") : Component(nullptr, name) {}
+
+  void update(double deltaTime) override { (void)deltaTime; }
+  void render() override {}
+};
+
+void testAxisResizeBehaviorFixedFixed() {
+  std::cout << "Testing AxisResizeBehavior::FIXED on both axes..." << std::endl;
+
+  TestComponent parent;
+  parent.setBounds(0, 0, 800, 600);
+
+  auto child = std::make_unique<TestComponent>("FixedChild");
+  child->setBounds(100, 100, 200, 150);
+  child->setAxisResizeBehavior(Component::AxisResizeBehavior::FIXED, Component::AxisResizeBehavior::FIXED);
+
+  auto* childPtr = child.get();
+  parent.addChild(std::move(child));
+
+  // Initial size
+  int x, y, w, h;
+  childPtr->getBounds(x, y, w, h);
+  assert(x == 100 && y == 100 && w == 200 && h == 150);
+
+  // Resize parent - both axes should stay FIXED
+  childPtr->onParentResize(1024, 768);
+
+  childPtr->getBounds(x, y, w, h);
+  assert(x == 100 && y == 100 && w == 200 && h == 150);
+
+  std::cout << "✓ AxisResizeBehavior::FIXED/FIXED test passed" << std::endl;
+}
+
+void testAxisResizeBehaviorFixedFill() {
+  std::cout << "Testing AxisResizeBehavior::FIXED horizontal, FILL vertical..." << std::endl;
+
+  TestComponent parent;
+  parent.setBounds(0, 0, 800, 600);
+
+  auto child = std::make_unique<TestComponent>("FixedFillChild");
+  child->setBounds(100, 0, 200, 600);
+  child->setAxisResizeBehavior(Component::AxisResizeBehavior::FIXED, Component::AxisResizeBehavior::FILL);
+
+  auto* childPtr = child.get();
+  parent.addChild(std::move(child));
+
+  // First call establishes original dimensions
+  childPtr->onParentResize(800, 600);
+
+  // Resize parent - horizontal should stay fixed, vertical should fill
+  childPtr->onParentResize(1024, 768);
+
+  int x, y, w, h;
+  childPtr->getBounds(x, y, w, h);
+  assert(x == 100 && y == 0 && w == 200 && h == 768); // Width stays 200, height fills 768
+
+  // Resize smaller
+  childPtr->onParentResize(640, 480);
+  childPtr->getBounds(x, y, w, h);
+  assert(x == 100 && y == 0 && w == 200 && h == 480); // Width stays 200, height fills 480
+
+  std::cout << "✓ AxisResizeBehavior::FIXED/FILL test passed" << std::endl;
+}
+
+void testAxisResizeBehaviorFillFixed() {
+  std::cout << "Testing AxisResizeBehavior::FILL horizontal, FIXED vertical..." << std::endl;
+
+  TestComponent parent;
+  parent.setBounds(0, 0, 800, 600);
+
+  auto child = std::make_unique<TestComponent>("FillFixedChild");
+  child->setBounds(0, 100, 800, 150);
+  child->setAxisResizeBehavior(Component::AxisResizeBehavior::FILL, Component::AxisResizeBehavior::FIXED);
+
+  auto* childPtr = child.get();
+  parent.addChild(std::move(child));
+
+  // First call establishes original dimensions
+  childPtr->onParentResize(800, 600);
+
+  // Resize parent - horizontal should fill, vertical should stay fixed
+  childPtr->onParentResize(1024, 768);
+
+  int x, y, w, h;
+  childPtr->getBounds(x, y, w, h);
+  assert(x == 0 && y == 100 && w == 1024 && h == 150); // Width fills 1024, height stays 150
+
+  // Resize smaller
+  childPtr->onParentResize(640, 480);
+  childPtr->getBounds(x, y, w, h);
+  assert(x == 0 && y == 100 && w == 640 && h == 150); // Width fills 640, height stays 150
+
+  std::cout << "✓ AxisResizeBehavior::FILL/FIXED test passed" << std::endl;
+}
+
+void testAxisResizeBehaviorFillFill() {
+  std::cout << "Testing AxisResizeBehavior::FILL on both axes..." << std::endl;
+
+  TestComponent parent;
+  parent.setBounds(0, 0, 800, 600);
+
+  auto child = std::make_unique<TestComponent>("FillFillChild");
+  child->setBounds(0, 0, 800, 600);
+  child->setAxisResizeBehavior(Component::AxisResizeBehavior::FILL, Component::AxisResizeBehavior::FILL);
+
+  auto* childPtr = child.get();
+  parent.addChild(std::move(child));
+
+  // Resize parent - both axes should fill
+  childPtr->onParentResize(1024, 768);
+
+  int x, y, w, h;
+  childPtr->getBounds(x, y, w, h);
+  assert(x == 0 && y == 0 && w == 1024 && h == 768);
+
+  // Resize smaller
+  childPtr->onParentResize(640, 480);
+  childPtr->getBounds(x, y, w, h);
+  assert(x == 0 && y == 0 && w == 640 && h == 480);
+
+  std::cout << "✓ AxisResizeBehavior::FILL/FILL test passed" << std::endl;
+}
+
+void testAxisResizeBehaviorScaleScale() {
+  std::cout << "Testing AxisResizeBehavior::SCALE on both axes..." << std::endl;
+
+  TestComponent parent;
+  parent.setBounds(0, 0, 800, 600);
+
+  auto child = std::make_unique<TestComponent>("ScaleScaleChild");
+  child->setBounds(100, 100, 200, 150);
+  child->setAxisResizeBehavior(Component::AxisResizeBehavior::SCALE, Component::AxisResizeBehavior::SCALE);
+
+  auto* childPtr = child.get();
+  parent.addChild(std::move(child));
+
+  // First call establishes original dimensions
+  childPtr->onParentResize(800, 600);
+
+  // Resize to 2x
+  childPtr->onParentResize(1600, 1200);
+
+  int x, y, w, h;
+  childPtr->getBounds(x, y, w, h);
+  assert(x == 200 && y == 200 && w == 400 && h == 300); // Everything scaled by 2
+
+  // Resize to 0.5x
+  childPtr->onParentResize(400, 300);
+  childPtr->getBounds(x, y, w, h);
+  assert(x == 50 && y == 50 && w == 100 && h == 75); // Everything scaled by 0.5
+
+  std::cout << "✓ AxisResizeBehavior::SCALE/SCALE test passed" << std::endl;
+}
+
+void testAxisResizeBehaviorMixedScale() {
+  std::cout << "Testing AxisResizeBehavior::SCALE horizontal, FIXED vertical..." << std::endl;
+
+  TestComponent parent;
+  parent.setBounds(0, 0, 800, 600);
+
+  auto child = std::make_unique<TestComponent>("ScaleFixedChild");
+  child->setBounds(100, 100, 200, 150);
+  child->setAxisResizeBehavior(Component::AxisResizeBehavior::SCALE, Component::AxisResizeBehavior::FIXED);
+
+  auto* childPtr = child.get();
+  parent.addChild(std::move(child));
+
+  // First call establishes original dimensions
+  childPtr->onParentResize(800, 600);
+
+  // Resize to 2x width, 1.5x height (but height should stay fixed)
+  childPtr->onParentResize(1600, 900);
+
+  int x, y, w, h;
+  childPtr->getBounds(x, y, w, h);
+  assert(x == 200 && y == 100 && w == 400 && h == 150); // Width scaled by 2, height stays 150
+
+  std::cout << "✓ AxisResizeBehavior::SCALE/FIXED test passed" << std::endl;
+}
+
+void testUnifiedBehaviorStillWorksAfterAxisBehavior() {
+  std::cout << "Testing that unified behavior still works after setting axis behavior..." << std::endl;
+
+  TestComponent parent;
+  parent.setBounds(0, 0, 800, 600);
+
+  auto child = std::make_unique<TestComponent>("UnifiedChild");
+  child->setBounds(0, 0, 800, 600);
+
+  // First set axis behavior
+  child->setAxisResizeBehavior(Component::AxisResizeBehavior::FILL, Component::AxisResizeBehavior::FILL);
+
+  // Then switch back to unified behavior
+  child->setResizeBehavior(Component::ResizeBehavior::FIXED);
+
+  auto* childPtr = child.get();
+  parent.addChild(std::move(child));
+
+  // Resize parent - should use FIXED behavior (unified)
+  childPtr->onParentResize(1024, 768);
+
+  int x, y, w, h;
+  childPtr->getBounds(x, y, w, h);
+  assert(x == 0 && y == 0 && w == 800 && h == 600); // Should stay at original size
+
+  std::cout << "✓ Unified behavior after axis behavior test passed" << std::endl;
+}
+
+int main() {
+  std::cout << "=== Per-Axis Resize Behavior Tests ===" << std::endl << std::endl;
+
+  try {
+    testAxisResizeBehaviorFixedFixed();
+    testAxisResizeBehaviorFixedFill();
+    testAxisResizeBehaviorFillFixed();
+    testAxisResizeBehaviorFillFill();
+    testAxisResizeBehaviorScaleScale();
+    testAxisResizeBehaviorMixedScale();
+    testUnifiedBehaviorStillWorksAfterAxisBehavior();
+
+    std::cout << std::endl << "✓ All per-axis resize behavior tests passed!" << std::endl;
+    return 0;
+  } catch (const std::exception& e) {
+    std::cerr << "✗ Test failed with exception: " << e.what() << std::endl;
+    return 1;
+  } catch (...) {
+    std::cerr << "✗ Test failed with unknown exception" << std::endl;
+    return 1;
+  }
+}
diff --git a/tests/test_component_resize.cpp b/tests/test_component_resize.cpp
new file mode 100644
index 0000000..29f6b6f
--- /dev/null
+++ b/tests/test_component_resize.cpp
@@ -0,0 +1,225 @@
+/**
+ * @file test_component_resize.cpp
+ * @brief Unit tests for component resize handling
+ */
+
+#include <bombfork/prong/core/component.h>
+
+#include <cassert>
+#include <exception>
+#include <iostream>
+#include <memory>
+#include <string>
+#include <utility>
+
+using namespace bombfork::prong;
+
+// Simple concrete component for testing
+class TestComponent : public Component {
+public:
+  explicit TestComponent(const std::string& name = "TestComponent") : Component(nullptr, name) {}
+
+  void update(double deltaTime) override { (void)deltaTime; }
+  void render() override {}
+};
+
+void testResizeBehaviorFixed() {
+  std::cout << "Testing ResizeBehavior::FIXED..." << std::endl;
+
+  TestComponent parent;
+  parent.setBounds(0, 0, 800, 600);
+
+  auto child = std::make_unique<TestComponent>("FixedChild");
+  child->setBounds(100, 100, 200, 150);
+  child->setResizeBehavior(Component::ResizeBehavior::FIXED);
+
+  auto* childPtr = child.get();
+  parent.addChild(std::move(child));
+
+  // Initial size
+  int x, y, w, h;
+  childPtr->getBounds(x, y, w, h);
+  assert(x == 100 && y == 100 && w == 200 && h == 150);
+
+  // Resize parent - FIXED should not change
+  childPtr->onParentResize(1024, 768);
+
+  childPtr->getBounds(x, y, w, h);
+  assert(x == 100 && y == 100 && w == 200 && h == 150);
+
+  std::cout << "✓ ResizeBehavior::FIXED test passed" << std::endl;
+}
+
+void testResizeBehaviorFill() {
+  std::cout << "Testing ResizeBehavior::FILL..." << std::endl;
+
+  TestComponent parent;
+  parent.setBounds(0, 0, 800, 600);
+
+  auto child = std::make_unique<TestComponent>("FillChild");
+  child->setBounds(0, 0, 800, 600);
+  child->setResizeBehavior(Component::ResizeBehavior::FILL);
+
+  auto* childPtr = child.get();
+  parent.addChild(std::move(child));
+
+  // Resize parent larger - FILL should match parent size (grow)
+  childPtr->onParentResize(1024, 768);
+
+  int x, y, w, h;
+  childPtr->getBounds(x, y, w, h);
+  assert(x == 0 && y == 0 && w == 1024 && h == 768);
+
+  // Resize parent smaller - FILL should match parent size (shrink)
+  childPtr->onParentResize(640, 480);
+  childPtr->getBounds(x, y, w, h);
+  assert(x == 0 && y == 0 && w == 640 && h == 480);
+
+  std::cout << "✓ ResizeBehavior::FILL test passed (grow and shrink)" << std::endl;
+}
+
+void testResizeBehaviorScale() {
+  std::cout << "Testing ResizeBehavior::SCALE..." << std::endl;
+
+  TestComponent parent;
+  parent.setBounds(0, 0, 800, 600);
+
+  auto child = std::make_unique<TestComponent>("ScaleChild");
+  child->setBounds(100, 100, 200, 150);
+  child->setResizeBehavior(Component::ResizeBehavior::SCALE);
+
+  auto* childPtr = child.get();
+  parent.addChild(std::move(child));
+
+  // First call to onParentResize establishes original parent size
+  childPtr->onParentResize(800, 600);
+
+  // Resize to 2x - should scale proportionally (grow)
+  childPtr->onParentResize(1600, 1200);
+
+  int x, y, w, h;
+  childPtr->getBounds(x, y, w, h);
+  assert(x == 200 && y == 200 && w == 400 && h == 300);
+
+  // Resize to 0.5x - should scale proportionally (shrink)
+  childPtr->onParentResize(400, 300);
+  childPtr->getBounds(x, y, w, h);
+  assert(x == 50 && y == 50 && w == 100 && h == 75);
+
+  std::cout << "✓ ResizeBehavior::SCALE test passed (grow and shrink)" << std::endl;
+}
+
+void testResizeBehaviorMaintainAspect() {
+  std::cout << "Testing ResizeBehavior::MAINTAIN_ASPECT..." << std::endl;
+
+  TestComponent parent;
+  parent.setBounds(0, 0, 800, 600);
+
+  auto child = std::make_unique<TestComponent>("AspectChild");
+  child->setBounds(0, 0, 400, 300); // 4:3 aspect ratio
+  child->setResizeBehavior(Component::ResizeBehavior::MAINTAIN_ASPECT);
+
+  auto* childPtr = child.get();
+  parent.addChild(std::move(child));
+
+  // First call establishes original parent size
+  childPtr->onParentResize(800, 600);
+
+  // Resize to different aspect ratio - child should maintain its aspect
+  childPtr->onParentResize(1200, 600); // Wide parent
+
+  int x, y, w, h;
+  childPtr->getBounds(x, y, w, h);
+
+  // Should maintain 4:3 aspect ratio and be centered
+  assert(w == 400 && h == 300); // Same scale (1.0x) since height limited it
+
+  std::cout << "✓ ResizeBehavior::MAINTAIN_ASPECT test passed" << std::endl;
+}
+
+void testResponsiveConstraints() {
+  std::cout << "Testing ResponsiveConstraints..." << std::endl;
+
+  TestComponent parent;
+  parent.setBounds(0, 0, 800, 600);
+
+  auto child = std::make_unique<TestComponent>("ConstrainedChild");
+  child->setBounds(0, 0, 500, 400);
+  child->setResizeBehavior(Component::ResizeBehavior::FILL);
+
+  // Set constraints
+  Component::ResponsiveConstraints constraints;
+  constraints.minWidth = 200;
+  constraints.minHeight = 150;
+  constraints.maxWidth = 600;
+  constraints.maxHeight = 450;
+  child->setConstraints(constraints);
+
+  auto* childPtr = child.get();
+  parent.addChild(std::move(child));
+
+  // Try to resize beyond max - should be clamped
+  childPtr->onParentResize(1000, 1000);
+
+  int x, y, w, h;
+  childPtr->getBounds(x, y, w, h);
+  assert(w == 600 && h == 450); // Clamped to max
+
+  std::cout << "✓ ResponsiveConstraints test passed" << std::endl;
+}
+
+void testResizePropagation() {
+  std::cout << "Testing resize propagation through hierarchy..." << std::endl;
+
+  TestComponent root;
+  root.setBounds(0, 0, 800, 600);
+
+  auto parent = std::make_unique<TestComponent>("Parent");
+  parent->setBounds(0, 0, 800, 600);
+  parent->setResizeBehavior(Component::ResizeBehavior::FILL);
+
+  auto child = std::make_unique<TestComponent>("Child");
+  child->setBounds(0, 0, 800, 600);
+  child->setResizeBehavior(Component::ResizeBehavior::FILL);
+
+  auto* childPtr = child.get();
+  parent->addChild(std::move(child));
+
+  auto* parentPtr = parent.get();
+  root.addChild(std::move(parent));
+
+  // Resize root - should propagate to children
+  parentPtr->onParentResize(1024, 768);
+
+  int px, py, pw, ph;
+  parentPtr->getBounds(px, py, pw, ph);
+  assert(pw == 1024 && ph == 768);
+
+  int cx, cy, cw, ch;
+  childPtr->getBounds(cx, cy, cw, ch);
+  assert(cw == 1024 && ch == 768);
+
+  std::cout << "✓ Resize propagation test passed" << std::endl;
+}
+
+int main() {
+  std::cout << "=== Component Resize Handling Tests ===" << std::endl << std::endl;
+
+  try {
+    testResizeBehaviorFixed();
+    testResizeBehaviorFill();
+    testResizeBehaviorScale();
+    testResizeBehaviorMaintainAspect();
+    testResponsiveConstraints();
+    testResizePropagation();
+
+    std::cout << std::endl << "✓ All resize handling tests passed!" << std::endl;
+    return 0;
+  } catch (const std::exception& e) {
+    std::cerr << "✗ Test failed with exception: " << e.what() << std::endl;
+    return 1;
+  } catch (...) {
+    std::cerr << "✗ Test failed with unknown exception" << std::endl;
+    return 1;
+  }
+}
diff --git a/tests/test_resize_shrink.cpp b/tests/test_resize_shrink.cpp
new file mode 100644
index 0000000..f8a9582
--- /dev/null
+++ b/tests/test_resize_shrink.cpp
@@ -0,0 +1,103 @@
+/**
+ * @file test_resize_shrink.cpp
+ * @brief Test component resize shrinking behavior
+ */
+
+#include <bombfork/prong/core/component.h>
+
+#include <cassert>
+#include <iostream>
+#include <memory>
+#include <string>
+#include <utility>
+
+using namespace bombfork::prong;
+
+// Simple concrete component for testing
+class TestComponent : public Component {
+public:
+  explicit TestComponent(const std::string& name = "TestComponent") : Component(nullptr, name) {}
+
+  void update(double deltaTime) override { (void)deltaTime; }
+  void render() override {}
+};
+
+int main() {
+  std::cout << "=== Testing Resize SHRINKING Behavior ===" << std::endl << std::endl;
+
+  // Test FILL behavior with shrinking
+  {
+    std::cout << "Test 1: FILL behavior - grow then shrink" << std::endl;
+    TestComponent parent;
+    parent.setBounds(0, 0, 800, 600);
+
+    auto child = std::make_unique<TestComponent>("FillChild");
+    child->setBounds(0, 0, 800, 600);
+    child->setResizeBehavior(Component::ResizeBehavior::FILL);
+
+    auto* childPtr = child.get();
+    parent.addChild(std::move(child));
+
+    // Grow
+    std::cout << "  Growing to 1024x768..." << std::endl;
+    childPtr->onParentResize(1024, 768);
+    int x, y, w, h;
+    childPtr->getBounds(x, y, w, h);
+    std::cout << "  After grow: " << w << "x" << h << std::endl;
+    assert(w == 1024 && h == 768);
+
+    // Shrink
+    std::cout << "  Shrinking to 640x480..." << std::endl;
+    childPtr->onParentResize(640, 480);
+    childPtr->getBounds(x, y, w, h);
+    std::cout << "  After shrink: " << w << "x" << h << std::endl;
+    assert(w == 640 && h == 480);
+
+    std::cout << "  ✓ FILL shrink test PASSED" << std::endl << std::endl;
+  }
+
+  // Test SCALE behavior with shrinking
+  {
+    std::cout << "Test 2: SCALE behavior - grow then shrink" << std::endl;
+    TestComponent parent;
+    parent.setBounds(0, 0, 800, 600);
+
+    auto child = std::make_unique<TestComponent>("ScaleChild");
+    child->setBounds(100, 100, 200, 150);
+    child->setResizeBehavior(Component::ResizeBehavior::SCALE);
+
+    auto* childPtr = child.get();
+    parent.addChild(std::move(child));
+
+    // Establish original parent size
+    std::cout << "  Establishing original parent size 800x600..." << std::endl;
+    childPtr->onParentResize(800, 600);
+
+    // Grow to 1600x1200 (2x)
+    std::cout << "  Growing to 1600x1200 (2x)..." << std::endl;
+    childPtr->onParentResize(1600, 1200);
+    int x, y, w, h;
+    childPtr->getBounds(x, y, w, h);
+    std::cout << "  After grow: pos=(" << x << "," << y << ") size=" << w << "x" << h << std::endl;
+    std::cout << "  Expected: pos=(200,200) size=400x300" << std::endl;
+    assert(x == 200 && y == 200 && w == 400 && h == 300);
+
+    // Shrink to 400x300 (0.5x of original)
+    std::cout << "  Shrinking to 400x300 (0.5x)..." << std::endl;
+    childPtr->onParentResize(400, 300);
+    childPtr->getBounds(x, y, w, h);
+    std::cout << "  After shrink: pos=(" << x << "," << y << ") size=" << w << "x" << h << std::endl;
+    std::cout << "  Expected: pos=(50,50) size=100x75" << std::endl;
+
+    if (x == 50 && y == 50 && w == 100 && h == 75) {
+      std::cout << "  ✓ SCALE shrink test PASSED" << std::endl << std::endl;
+    } else {
+      std::cout << "  ✗ SCALE shrink test FAILED - sizes don't match!" << std::endl;
+      std::cout << "  This confirms the bug: SCALE doesn't work properly when shrinking!" << std::endl << std::endl;
+      return 1;
+    }
+  }
+
+  std::cout << "✓ All shrinking tests passed!" << std::endl;
+  return 0;
+}