diff --git a/README.md b/README.md
index 9d11321..e6c7964 100644
--- a/README.md
+++ b/README.md
@@ -293,6 +293,54 @@ def table_rows(items):
     ])
 ```
 
+### Form Builder
+
+Generate HTML5 forms with validation using the `Field` class:
+
+```python
+from nitro_ui import *
+
+form = Form(
+    Field.email("email", label="Email", required=True),
+    Field.password("password", label="Password", min_length=8),
+    Field.select("country", ["USA", "Canada", "Mexico"], label="Country"),
+    Field.checkbox("terms", label="I agree to the Terms", required=True),
+    Button("Sign Up", type="submit"),
+    action="/register"
+)
+```
+
+Field types: `text`, `email`, `password`, `url`, `tel`, `search`, `textarea`, `number`, `range`, `date`, `time`, `datetime_local`, `select`, `checkbox`, `radio`, `file`, `hidden`, `color`. See [SKILL.md](SKILL.md) for full API.
+
+### HTMX Integration
+
+Build interactive UIs without JavaScript. NitroUI converts `hx_*` kwargs to `hx-*` attributes automatically:
+
+```python
+from nitro_ui import *
+
+# Live search
+Input(
+    type="text",
+    hx_get="/search",
+    hx_trigger="keyup changed delay:300ms",
+    hx_target="#results"
+)
+
+# Delete with confirmation
+Button(
+    "Delete",
+    hx_delete="/items/1",
+    hx_confirm="Are you sure?",
+    hx_swap="outerHTML"
+)
+
+# Load more
+Button("Load More", hx_get="/items?page=2", hx_target="#list", hx_swap="beforeend")
+```
+
+All HTMX attributes are supported: `hx_get`, `hx_post`, `hx_put`, `hx_delete`, `hx_target`, `hx_swap`, `hx_trigger`, `hx_confirm`, `hx_indicator`, `hx_boost`, and more. See [SKILL.md](SKILL.md) for the complete reference.
+
 ### Raw HTML Partials
 
 Embed raw HTML for trusted content like analytics tags:
diff --git a/SKILL.md b/SKILL.md
index c8b973a..dae2639 100644
--- a/SKILL.md
+++ b/SKILL.md
@@ -805,6 +805,195 @@ def home(request):
 
 ---
 
+## Form Builder
+
+Generate HTML5 form fields with validation attributes using the `Field` class.
+
+```python
+from nitro_ui import Form, Button, Field
+
+form = Form(
+    Field.email("email", label="Email", required=True, placeholder="you@example.com"),
+    Field.password("password", label="Password", min_length=8),
+    Field.checkbox("remember", label="Remember me"),
+    Button("Log In", type="submit"),
+    action="/login",
+    method="post"
+)
+```
+
+### Text Fields
+
+```python
+Field.text(name, label=None, required=False, min_length=None, max_length=None, pattern=None, placeholder=None, value=None, wrapper=None, **attrs)
+Field.email(name, label=None, required=False, placeholder=None, value=None, wrapper=None, **attrs)
+Field.password(name, label=None, required=False, min_length=None, max_length=None, placeholder=None, wrapper=None, **attrs)
+Field.url(name, label=None, required=False, placeholder=None, value=None, wrapper=None, **attrs)
+Field.tel(name, label=None, required=False, pattern=None, placeholder=None, value=None, wrapper=None, **attrs)
+Field.search(name, label=None, required=False, placeholder=None, value=None, wrapper=None, **attrs)
+Field.textarea(name, label=None, required=False, rows=None, cols=None, min_length=None, max_length=None, placeholder=None, value=None, wrapper=None, **attrs)
+```
+
+### Numeric & Date Fields
+
+```python
+Field.number(name, label=None, required=False, min=None, max=None, step=None, value=None, wrapper=None, **attrs)
+Field.range(name, label=None, min=0, max=100, step=None, value=None, wrapper=None, **attrs)
+Field.date(name, label=None, required=False, min=None, max=None, value=None, wrapper=None, **attrs)
+Field.time(name, label=None, required=False, min=None, max=None, value=None, wrapper=None, **attrs)
+Field.datetime_local(name, label=None, required=False, min=None, max=None, value=None, wrapper=None, **attrs)
+```
+
+### Selection Fields
+
+```python
+# Select with different option formats
+Field.select("country", ["USA", "Canada", "Mexico"])  # strings
+Field.select("status", [("active", "Active"), ("inactive", "Inactive")])  # tuples
+Field.select("priority", [{"value": "1", "label": "Low", "disabled": True}])  # dicts
+
+# Pre-selected value
+Field.select("country", ["USA", "Canada"], value="Canada", label="Country")
+
+# Checkbox (label wraps input)
+Field.checkbox("terms", label="I agree to the Terms", required=True)
+
+# Radio buttons (wrapped in fieldset)
+Field.radio("plan", [("free", "Free"), ("pro", "Pro")], label="Select Plan", value="free")
+```
+
+### Other Fields
+
+```python
+Field.file(name, label=None, required=False, accept=None, multiple=False, wrapper=None, **attrs)
+Field.hidden(name, value, **attrs)
+Field.color(name, label=None, value=None, wrapper=None, **attrs)
+```
+
+### Labels and Wrappers
+
+```python
+# No label - just input
+Field.text("username")
+
+# With label
+Field.text("username", label="Username")
+# → <label for="username">Username</label><input ...>
+
+# With wrapper div
+Field.text("username", label="Username", wrapper="form-field")
+# → <div class="form-field"><label>...</label><input ...></div>
+
+# Wrapper with attributes
+Field.text("username", label="Username", wrapper={"cls": "form-group", "id": "field-1"})
+```
+
+### With HTMX
+
+```python
+Field.text("search",
+    placeholder="Search...",
+    hx_get="/search",
+    hx_trigger="keyup changed delay:300ms",
+    hx_target="#results"
+)
+```
+
+---
+
+## HTMX Integration
+
+NitroUI works seamlessly with [HTMX](https://htmx.org/). Use `hx_*` kwargs — underscores convert to hyphens automatically.
+
+### Basic Usage
+
+```python
+from nitro_ui import Button, Div, Input, Script
+
+# Include HTMX
+Script(src="https://unpkg.com/htmx.org@2.0.4")
+
+# hx_get → hx-get, hx_target → hx-target, etc.
+Button("Load More", hx_get="/items", hx_target="#list", hx_swap="beforeend")
+```
+
+### Common Patterns
+
+```python
+# Click to load
+Button("Load", hx_get="/content", hx_target="#result")
+
+# Delete with confirmation
+Button("Delete", hx_delete="/items/1", hx_confirm="Are you sure?", hx_swap="outerHTML")
+
+# Live search
+Input(
+    type="text",
+    name="q",
+    hx_get="/search",
+    hx_trigger="keyup changed delay:300ms",
+    hx_target="#results"
+)
+
+# Form submission
+Form(
+    Input(type="text", name="email"),
+    Button("Subscribe"),
+    hx_post="/subscribe",
+    hx_swap="outerHTML"
+)
+
+# Infinite scroll
+Div(
+    hx_get="/items?page=2",
+    hx_trigger="revealed",
+    hx_swap="afterend"
+)
+
+# Polling
+Div(id="notifications", hx_get="/notifications", hx_trigger="every 30s")
+```
+
+### All HTMX Attributes
+
+| Python kwarg | HTML attribute | Description |
+|--------------|----------------|-------------|
+| `hx_get` | `hx-get` | GET request |
+| `hx_post` | `hx-post` | POST request |
+| `hx_put` | `hx-put` | PUT request |
+| `hx_patch` | `hx-patch` | PATCH request |
+| `hx_delete` | `hx-delete` | DELETE request |
+| `hx_target` | `hx-target` | Target element selector |
+| `hx_swap` | `hx-swap` | How to swap content |
+| `hx_trigger` | `hx-trigger` | Event that triggers request |
+| `hx_confirm` | `hx-confirm` | Confirmation dialog |
+| `hx_indicator` | `hx-indicator` | Loading indicator |
+| `hx_push_url` | `hx-push-url` | Push URL to history |
+| `hx_select` | `hx-select` | Select content from response |
+| `hx_select_oob` | `hx-select-oob` | Out-of-band select |
+| `hx_swap_oob` | `hx-swap-oob` | Out-of-band swap |
+| `hx_vals` | `hx-vals` | Additional values (JSON) |
+| `hx_boost` | `hx-boost` | Boost all links/forms |
+| `hx_include` | `hx-include` | Include additional inputs |
+| `hx_params` | `hx-params` | Filter parameters |
+| `hx_preserve` | `hx-preserve` | Preserve element |
+| `hx_ext` | `hx-ext` | Extensions |
+
+### HTMX Extensions
+
+```python
+# Server-Sent Events
+Div(hx_ext="sse", sse_connect="/events", sse_swap="message")
+
+# WebSockets
+Div(hx_ext="ws", ws_connect="/ws")
+
+# JSON encoding
+Form(hx_ext="json-enc", hx_post="/api/submit")
+```
+
+---
+
 ## Security
 
 - **Automatic HTML escaping**: All text content and attribute values are escaped
@@ -841,3 +1030,4 @@ When generating NitroUI code:
 - [ ] Use `Fragment` when you need multiple elements without a wrapper
 - [ ] Use `Partial` for raw HTML (analytics, embeds) - bypasses escaping
 - [ ] Use `Component` + `Slot` for reusable components with declarative templates
+- [ ] Use `Field.xyz()` for form fields with HTML5 validation attributes
diff --git a/docs/plans/2026-01-30-form-builder-design.md b/docs/plans/2026-01-30-form-builder-design.md
new file mode 100644
index 0000000..a7748d2
--- /dev/null
+++ b/docs/plans/2026-01-30-form-builder-design.md
@@ -0,0 +1,176 @@
+# Form Builder Design
+
+## Overview
+
+A declarative form field API that generates HTML5 form elements with validation attributes. Field functions return standard NitroUI elements, making them fully composable with the rest of the library.
+
+**Goals:**
+- Simple, NitroUI-like API using static methods on a `Field` class
+- HTML5 validation only (no server-side validation in v1)
+- Optional labels and wrappers for flexible layouts
+- Full HTML5 input type coverage
+
+## Basic API
+
+```python
+from nitro_ui import Form, Button
+from nitro_ui.forms import Field
+
+form = Form(
+    Field.email("email", label="Email", required=True, placeholder="you@example.com"),
+    Field.password("password", label="Password", min_length=8),
+    Button("Log In", type="submit"),
+    action="/login",
+    method="post"
+)
+```
+
+**Renders:**
+
+```html
+<form action="/login" method="post">
+    <label for="email">Email</label>
+    <input type="email" id="email" name="email" required placeholder="you@example.com">
+    <label for="password">Password</label>
+    <input type="password" id="password" name="password" minlength="8">
+    <button type="submit">Log In</button>
+</form>
+```
+
+## Field Types
+
+### Text Inputs
+
+```python
+Field.text(name, label=None, required=False, min_length=None, max_length=None, pattern=None, placeholder=None, value=None, **attrs)
+Field.email(name, label=None, required=False, placeholder=None, value=None, **attrs)
+Field.password(name, label=None, required=False, min_length=None, max_length=None, placeholder=None, **attrs)
+Field.url(name, label=None, required=False, placeholder=None, value=None, **attrs)
+Field.tel(name, label=None, required=False, pattern=None, placeholder=None, value=None, **attrs)
+Field.search(name, label=None, required=False, placeholder=None, value=None, **attrs)
+Field.textarea(name, label=None, required=False, rows=None, cols=None, min_length=None, max_length=None, placeholder=None, value=None, **attrs)
+```
+
+### Numeric
+
+```python
+Field.number(name, label=None, required=False, min=None, max=None, step=None, value=None, **attrs)
+Field.range(name, label=None, min=0, max=100, step=None, value=None, **attrs)
+```
+
+### Date/Time
+
+```python
+Field.date(name, label=None, required=False, min=None, max=None, value=None, **attrs)
+Field.time(name, label=None, required=False, min=None, max=None, value=None, **attrs)
+Field.datetime_local(name, label=None, required=False, min=None, max=None, value=None, **attrs)
+```
+
+### Selection
+
+```python
+Field.select(name, options, label=None, required=False, value=None, **attrs)
+Field.checkbox(name, label=None, checked=False, value="on", **attrs)
+Field.radio(name, options, label=None, required=False, value=None, **attrs)
+```
+
+### Other
+
+```python
+Field.file(name, label=None, required=False, accept=None, multiple=False, **attrs)
+Field.hidden(name, value, **attrs)
+Field.color(name, label=None, value=None, **attrs)
+```
+
+## Label Behavior
+
+**Without label:**
+```python
+Field.email("email", required=True)
+# <input type="email" id="email" name="email" required>
+```
+
+**With label:**
+```python
+Field.email("email", label="Email Address", required=True)
+# <label for="email">Email Address</label>
+# <input type="email" id="email" name="email" required>
+```
+
+**With wrapper:**
+```python
+Field.email("email", label="Email", required=True, wrapper="field")
+# <div class="field">
+#     <label for="email">Email</label>
+#     <input type="email" id="email" name="email" required>
+# </div>
+
+Field.email("email", label="Email", wrapper={"cls": "form-group", "id": "email-field"})
+# <div class="form-group" id="email-field">...</div>
+```
+
+**Custom ID:**
+```python
+Field.email("user_email", id="email-input", label="Email")
+# <label for="email-input">Email</label>
+# <input type="email" id="email-input" name="user_email">
+```
+
+## Select Options
+
+Three formats supported:
+
+```python
+# Simple list
+Field.select("country", ["USA", "Canada", "Mexico"])
+
+# Tuples (value, label)
+Field.select("status", [("active", "Active"), ("inactive", "Inactive")])
+
+# Dicts (full control)
+Field.select("priority", [
+    {"value": "1", "label": "Low"},
+    {"value": "2", "label": "Medium", "disabled": True}
+])
+```
+
+## Radio Buttons
+
+```python
+Field.radio("plan", [
+    ("free", "Free"),
+    ("pro", "Pro - $10/mo")
+], label="Plan", value="free")
+```
+
+**Renders:**
+```html
+<fieldset>
+    <legend>Plan</legend>
+    <label><input type="radio" name="plan" value="free" checked> Free</label>
+    <label><input type="radio" name="plan" value="pro"> Pro - $10/mo</label>
+</fieldset>
+```
+
+## Checkbox
+
+```python
+Field.checkbox("subscribe", label="Subscribe to newsletter", checked=True)
+# <label><input type="checkbox" name="subscribe" value="on" checked> Subscribe to newsletter</label>
+```
+
+## File Structure
+
+```
+src/nitro_ui/
+├── forms/
+│   ├── __init__.py    # exports Field
+│   └── field.py       # Field class with static methods
+```
+
+## Export
+
+```python
+from nitro_ui import Field
+from nitro_ui.forms import Field  # alternative
+```
diff --git a/src/nitro_ui/__init__.py b/src/nitro_ui/__init__.py
index 1df8d02..2d283e8 100644
--- a/src/nitro_ui/__init__.py
+++ b/src/nitro_ui/__init__.py
@@ -4,6 +4,7 @@
 from .core.parser import from_html
 from .core.slot import Slot
 from .core.component import Component
+from .forms import Field
 from .tags.form import (
     Textarea,
     Select,
@@ -132,6 +133,7 @@
     "from_html",
     "Slot",
     "Component",
+    "Field",
     # styles
     "CSSStyle",
     "StyleSheet",
diff --git a/src/nitro_ui/forms/__init__.py b/src/nitro_ui/forms/__init__.py
new file mode 100644
index 0000000..45bb248
--- /dev/null
+++ b/src/nitro_ui/forms/__init__.py
@@ -0,0 +1,5 @@
+"""Form field helpers for NitroUI."""
+
+from nitro_ui.forms.field import Field
+
+__all__ = ["Field"]
diff --git a/src/nitro_ui/forms/field.py b/src/nitro_ui/forms/field.py
new file mode 100644
index 0000000..ae31fb4
--- /dev/null
+++ b/src/nitro_ui/forms/field.py
@@ -0,0 +1,710 @@
+"""Form field helpers that generate HTML5 form elements with validation attributes."""
+
+from typing import Any, Dict, List, Optional, Union
+
+from nitro_ui.core.element import HTMLElement
+from nitro_ui.core.fragment import Fragment
+from nitro_ui.tags.layout import Div
+from nitro_ui.tags.form import Input, Label, Select, Option, Textarea, Fieldset, Legend
+
+
+def _build_field(
+    input_element: HTMLElement,
+    name: str,
+    label: Optional[str] = None,
+    wrapper: Optional[Union[str, Dict[str, Any]]] = None,
+    id: Optional[str] = None,
+) -> HTMLElement:
+    """Build a field with optional label and wrapper.
+
+    Args:
+        input_element: The input element to wrap
+        name: Field name (used for label's for attribute if no id)
+        label: Optional label text
+        wrapper: Optional wrapper - string for class name, dict for attributes
+        id: Optional custom id (defaults to name)
+
+    Returns:
+        HTMLElement - the input alone, with label, or wrapped in div
+    """
+    field_id = id or name
+
+    # Build elements list
+    elements = []
+
+    if label:
+        elements.append(Label(label, for_element=field_id))
+
+    elements.append(input_element)
+
+    # No label and no wrapper - just return the input
+    if len(elements) == 1 and not wrapper:
+        return input_element
+
+    # Has label but no wrapper - return fragment
+    if not wrapper:
+        return Fragment(*elements)
+
+    # Has wrapper - wrap in div
+    if isinstance(wrapper, str):
+        return Div(*elements, cls=wrapper)
+    elif isinstance(wrapper, dict):
+        return Div(*elements, **wrapper)
+    else:
+        return Div(*elements)
+
+
+def _filter_none(**kwargs) -> Dict[str, Any]:
+    """Filter out None values from kwargs."""
+    return {k: v for k, v in kwargs.items() if v is not None}
+
+
+class Field:
+    """Static methods for generating HTML5 form fields with validation attributes.
+
+    All methods return standard NitroUI elements that can be composed with
+    other elements. Use the `label` parameter to add a label, and `wrapper`
+    to wrap the field in a div for styling.
+
+    Example:
+        from nitro_ui import Form, Button
+        from nitro_ui.forms import Field
+
+        form = Form(
+            Field.email("email", label="Email", required=True),
+            Field.password("password", label="Password", min_length=8),
+            Button("Log In", type="submit")
+        )
+    """
+
+    # =========================================================================
+    # Text Inputs
+    # =========================================================================
+
+    @staticmethod
+    def text(
+        name: str,
+        label: Optional[str] = None,
+        required: bool = False,
+        min_length: Optional[int] = None,
+        max_length: Optional[int] = None,
+        pattern: Optional[str] = None,
+        placeholder: Optional[str] = None,
+        value: Optional[str] = None,
+        wrapper: Optional[Union[str, Dict[str, Any]]] = None,
+        id: Optional[str] = None,
+        **attrs
+    ) -> HTMLElement:
+        """Create a text input field.
+
+        Args:
+            name: Field name and default id
+            label: Optional label text
+            required: Whether the field is required
+            min_length: Minimum character length
+            max_length: Maximum character length
+            pattern: Regex pattern for validation
+            placeholder: Placeholder text
+            value: Default value
+            wrapper: Wrapper div class name or attributes dict
+            id: Custom id (defaults to name)
+            **attrs: Additional HTML attributes
+        """
+        field_id = id or name
+        input_attrs = _filter_none(
+            type="text",
+            id=field_id,
+            name=name,
+            required=required if required else None,
+            minlength=min_length,
+            maxlength=max_length,
+            pattern=pattern,
+            placeholder=placeholder,
+            value=value,
+            **attrs
+        )
+        inp = Input(**input_attrs)
+        return _build_field(inp, name, label, wrapper, id)
+
+    @staticmethod
+    def email(
+        name: str,
+        label: Optional[str] = None,
+        required: bool = False,
+        placeholder: Optional[str] = None,
+        value: Optional[str] = None,
+        wrapper: Optional[Union[str, Dict[str, Any]]] = None,
+        id: Optional[str] = None,
+        **attrs
+    ) -> HTMLElement:
+        """Create an email input field."""
+        field_id = id or name
+        input_attrs = _filter_none(
+            type="email",
+            id=field_id,
+            name=name,
+            required=required if required else None,
+            placeholder=placeholder,
+            value=value,
+            **attrs
+        )
+        inp = Input(**input_attrs)
+        return _build_field(inp, name, label, wrapper, id)
+
+    @staticmethod
+    def password(
+        name: str,
+        label: Optional[str] = None,
+        required: bool = False,
+        min_length: Optional[int] = None,
+        max_length: Optional[int] = None,
+        placeholder: Optional[str] = None,
+        wrapper: Optional[Union[str, Dict[str, Any]]] = None,
+        id: Optional[str] = None,
+        **attrs
+    ) -> HTMLElement:
+        """Create a password input field."""
+        field_id = id or name
+        input_attrs = _filter_none(
+            type="password",
+            id=field_id,
+            name=name,
+            required=required if required else None,
+            minlength=min_length,
+            maxlength=max_length,
+            placeholder=placeholder,
+            **attrs
+        )
+        inp = Input(**input_attrs)
+        return _build_field(inp, name, label, wrapper, id)
+
+    @staticmethod
+    def url(
+        name: str,
+        label: Optional[str] = None,
+        required: bool = False,
+        placeholder: Optional[str] = None,
+        value: Optional[str] = None,
+        wrapper: Optional[Union[str, Dict[str, Any]]] = None,
+        id: Optional[str] = None,
+        **attrs
+    ) -> HTMLElement:
+        """Create a URL input field."""
+        field_id = id or name
+        input_attrs = _filter_none(
+            type="url",
+            id=field_id,
+            name=name,
+            required=required if required else None,
+            placeholder=placeholder,
+            value=value,
+            **attrs
+        )
+        inp = Input(**input_attrs)
+        return _build_field(inp, name, label, wrapper, id)
+
+    @staticmethod
+    def tel(
+        name: str,
+        label: Optional[str] = None,
+        required: bool = False,
+        pattern: Optional[str] = None,
+        placeholder: Optional[str] = None,
+        value: Optional[str] = None,
+        wrapper: Optional[Union[str, Dict[str, Any]]] = None,
+        id: Optional[str] = None,
+        **attrs
+    ) -> HTMLElement:
+        """Create a telephone input field."""
+        field_id = id or name
+        input_attrs = _filter_none(
+            type="tel",
+            id=field_id,
+            name=name,
+            required=required if required else None,
+            pattern=pattern,
+            placeholder=placeholder,
+            value=value,
+            **attrs
+        )
+        inp = Input(**input_attrs)
+        return _build_field(inp, name, label, wrapper, id)
+
+    @staticmethod
+    def search(
+        name: str,
+        label: Optional[str] = None,
+        required: bool = False,
+        placeholder: Optional[str] = None,
+        value: Optional[str] = None,
+        wrapper: Optional[Union[str, Dict[str, Any]]] = None,
+        id: Optional[str] = None,
+        **attrs
+    ) -> HTMLElement:
+        """Create a search input field."""
+        field_id = id or name
+        input_attrs = _filter_none(
+            type="search",
+            id=field_id,
+            name=name,
+            required=required if required else None,
+            placeholder=placeholder,
+            value=value,
+            **attrs
+        )
+        inp = Input(**input_attrs)
+        return _build_field(inp, name, label, wrapper, id)
+
+    @staticmethod
+    def textarea(
+        name: str,
+        label: Optional[str] = None,
+        required: bool = False,
+        rows: Optional[int] = None,
+        cols: Optional[int] = None,
+        min_length: Optional[int] = None,
+        max_length: Optional[int] = None,
+        placeholder: Optional[str] = None,
+        value: Optional[str] = None,
+        wrapper: Optional[Union[str, Dict[str, Any]]] = None,
+        id: Optional[str] = None,
+        **attrs
+    ) -> HTMLElement:
+        """Create a textarea field."""
+        field_id = id or name
+        textarea_attrs = _filter_none(
+            id=field_id,
+            name=name,
+            required=required if required else None,
+            rows=rows,
+            cols=cols,
+            minlength=min_length,
+            maxlength=max_length,
+            placeholder=placeholder,
+            **attrs
+        )
+        # Textarea takes content as children, not value attribute
+        if value:
+            ta = Textarea(value, **textarea_attrs)
+        else:
+            ta = Textarea(**textarea_attrs)
+        return _build_field(ta, name, label, wrapper, id)
+
+    # =========================================================================
+    # Numeric Inputs
+    # =========================================================================
+
+    @staticmethod
+    def number(
+        name: str,
+        label: Optional[str] = None,
+        required: bool = False,
+        min: Optional[Union[int, float]] = None,
+        max: Optional[Union[int, float]] = None,
+        step: Optional[Union[int, float, str]] = None,
+        value: Optional[Union[int, float]] = None,
+        wrapper: Optional[Union[str, Dict[str, Any]]] = None,
+        id: Optional[str] = None,
+        **attrs
+    ) -> HTMLElement:
+        """Create a number input field."""
+        field_id = id or name
+        input_attrs = _filter_none(
+            type="number",
+            id=field_id,
+            name=name,
+            required=required if required else None,
+            min=min,
+            max=max,
+            step=step,
+            value=value,
+            **attrs
+        )
+        inp = Input(**input_attrs)
+        return _build_field(inp, name, label, wrapper, id)
+
+    @staticmethod
+    def range(
+        name: str,
+        label: Optional[str] = None,
+        min: Union[int, float] = 0,
+        max: Union[int, float] = 100,
+        step: Optional[Union[int, float, str]] = None,
+        value: Optional[Union[int, float]] = None,
+        wrapper: Optional[Union[str, Dict[str, Any]]] = None,
+        id: Optional[str] = None,
+        **attrs
+    ) -> HTMLElement:
+        """Create a range slider input field."""
+        field_id = id or name
+        input_attrs = _filter_none(
+            type="range",
+            id=field_id,
+            name=name,
+            min=min,
+            max=max,
+            step=step,
+            value=value,
+            **attrs
+        )
+        inp = Input(**input_attrs)
+        return _build_field(inp, name, label, wrapper, id)
+
+    # =========================================================================
+    # Date/Time Inputs
+    # =========================================================================
+
+    @staticmethod
+    def date(
+        name: str,
+        label: Optional[str] = None,
+        required: bool = False,
+        min: Optional[str] = None,
+        max: Optional[str] = None,
+        value: Optional[str] = None,
+        wrapper: Optional[Union[str, Dict[str, Any]]] = None,
+        id: Optional[str] = None,
+        **attrs
+    ) -> HTMLElement:
+        """Create a date input field.
+
+        Args:
+            min/max/value: Date strings in YYYY-MM-DD format
+        """
+        field_id = id or name
+        input_attrs = _filter_none(
+            type="date",
+            id=field_id,
+            name=name,
+            required=required if required else None,
+            min=min,
+            max=max,
+            value=value,
+            **attrs
+        )
+        inp = Input(**input_attrs)
+        return _build_field(inp, name, label, wrapper, id)
+
+    @staticmethod
+    def time(
+        name: str,
+        label: Optional[str] = None,
+        required: bool = False,
+        min: Optional[str] = None,
+        max: Optional[str] = None,
+        value: Optional[str] = None,
+        wrapper: Optional[Union[str, Dict[str, Any]]] = None,
+        id: Optional[str] = None,
+        **attrs
+    ) -> HTMLElement:
+        """Create a time input field.
+
+        Args:
+            min/max/value: Time strings in HH:MM format
+        """
+        field_id = id or name
+        input_attrs = _filter_none(
+            type="time",
+            id=field_id,
+            name=name,
+            required=required if required else None,
+            min=min,
+            max=max,
+            value=value,
+            **attrs
+        )
+        inp = Input(**input_attrs)
+        return _build_field(inp, name, label, wrapper, id)
+
+    @staticmethod
+    def datetime_local(
+        name: str,
+        label: Optional[str] = None,
+        required: bool = False,
+        min: Optional[str] = None,
+        max: Optional[str] = None,
+        value: Optional[str] = None,
+        wrapper: Optional[Union[str, Dict[str, Any]]] = None,
+        id: Optional[str] = None,
+        **attrs
+    ) -> HTMLElement:
+        """Create a datetime-local input field.
+
+        Args:
+            min/max/value: Datetime strings in YYYY-MM-DDTHH:MM format
+        """
+        field_id = id or name
+        input_attrs = _filter_none(
+            type="datetime-local",
+            id=field_id,
+            name=name,
+            required=required if required else None,
+            min=min,
+            max=max,
+            value=value,
+            **attrs
+        )
+        inp = Input(**input_attrs)
+        return _build_field(inp, name, label, wrapper, id)
+
+    # =========================================================================
+    # Selection Inputs
+    # =========================================================================
+
+    @staticmethod
+    def select(
+        name: str,
+        options: List[Union[str, tuple, Dict[str, Any]]],
+        label: Optional[str] = None,
+        required: bool = False,
+        value: Optional[str] = None,
+        wrapper: Optional[Union[str, Dict[str, Any]]] = None,
+        id: Optional[str] = None,
+        **attrs
+    ) -> HTMLElement:
+        """Create a select dropdown field.
+
+        Args:
+            name: Field name
+            options: List of options - can be:
+                - strings: ["USA", "Canada"] - value and label are the same
+                - tuples: [("us", "United States")] - (value, label)
+                - dicts: [{"value": "us", "label": "United States", "disabled": True}]
+            label: Optional label text
+            required: Whether selection is required
+            value: Pre-selected value
+            wrapper: Wrapper div class name or attributes dict
+            id: Custom id (defaults to name)
+        """
+        field_id = id or name
+
+        # Build option elements
+        option_elements = []
+        for opt in options:
+            if isinstance(opt, str):
+                opt_value = opt
+                opt_label = opt
+                opt_attrs = {}
+            elif isinstance(opt, tuple):
+                opt_value, opt_label = opt
+                opt_attrs = {}
+            elif isinstance(opt, dict):
+                opt_value = opt.get("value", "")
+                opt_label = opt.get("label", opt_value)
+                opt_attrs = {k: v for k, v in opt.items() if k not in ("value", "label")}
+            else:
+                continue
+
+            # Check if this option should be selected
+            if value is not None and str(opt_value) == str(value):
+                opt_attrs["selected"] = True
+
+            option_elements.append(Option(opt_label, value=opt_value, **opt_attrs))
+
+        select_attrs = _filter_none(
+            id=field_id,
+            name=name,
+            required=required if required else None,
+            **attrs
+        )
+        sel = Select(*option_elements, **select_attrs)
+        return _build_field(sel, name, label, wrapper, id)
+
+    @staticmethod
+    def checkbox(
+        name: str,
+        label: Optional[str] = None,
+        checked: bool = False,
+        value: str = "on",
+        wrapper: Optional[Union[str, Dict[str, Any]]] = None,
+        id: Optional[str] = None,
+        required: bool = False,
+        **attrs
+    ) -> HTMLElement:
+        """Create a checkbox field.
+
+        For checkboxes, the label wraps the input for better UX.
+
+        Args:
+            name: Field name
+            label: Label text (wraps the checkbox)
+            checked: Whether the checkbox is pre-checked
+            value: Value sent when checked (default "on")
+            wrapper: Wrapper div class name or attributes dict
+            id: Custom id (defaults to name)
+            required: Whether the checkbox must be checked
+        """
+        field_id = id or name
+        input_attrs = _filter_none(
+            type="checkbox",
+            id=field_id,
+            name=name,
+            value=value,
+            checked=checked if checked else None,
+            required=required if required else None,
+            **attrs
+        )
+        inp = Input(**input_attrs)
+
+        # For checkbox, label wraps the input (input first, then text)
+        if label:
+            # Use a fragment inside label to control order: input, space, text
+            from nitro_ui.tags.text import Span
+            labeled = Label(inp, Span(" " + label))
+            if wrapper:
+                if isinstance(wrapper, str):
+                    return Div(labeled, cls=wrapper)
+                elif isinstance(wrapper, dict):
+                    return Div(labeled, **wrapper)
+            return labeled
+
+        if wrapper:
+            if isinstance(wrapper, str):
+                return Div(inp, cls=wrapper)
+            elif isinstance(wrapper, dict):
+                return Div(inp, **wrapper)
+        return inp
+
+    @staticmethod
+    def radio(
+        name: str,
+        options: List[Union[tuple, Dict[str, Any]]],
+        label: Optional[str] = None,
+        required: bool = False,
+        value: Optional[str] = None,
+        wrapper: Optional[Union[str, Dict[str, Any]]] = None,
+        **attrs
+    ) -> HTMLElement:
+        """Create a radio button group.
+
+        Radio buttons are wrapped in a fieldset with legend for accessibility.
+
+        Args:
+            name: Field name (shared by all radio buttons)
+            options: List of options - tuples or dicts like select()
+            label: Legend text for the fieldset
+            required: Whether selection is required
+            value: Pre-selected value
+            wrapper: Wrapper div class name or attributes dict
+        """
+        # Build radio button elements
+        radio_elements = []
+        for i, opt in enumerate(options):
+            if isinstance(opt, tuple):
+                opt_value, opt_label = opt
+                opt_attrs = {}
+            elif isinstance(opt, dict):
+                opt_value = opt.get("value", "")
+                opt_label = opt.get("label", opt_value)
+                opt_attrs = {k: v for k, v in opt.items() if k not in ("value", "label")}
+            else:
+                continue
+
+            radio_id = f"{name}_{i}"
+            input_attrs = _filter_none(
+                type="radio",
+                id=radio_id,
+                name=name,
+                value=opt_value,
+                required=required if required and i == 0 else None,  # Only first needs required
+                checked=True if value is not None and str(opt_value) == str(value) else None,
+                **opt_attrs,
+                **attrs
+            )
+            inp = Input(**input_attrs)
+            radio_elements.append(Label(inp, " ", opt_label))
+
+        # Wrap in fieldset with legend
+        if label:
+            fieldset = Fieldset(Legend(label), *radio_elements)
+        else:
+            fieldset = Fieldset(*radio_elements)
+
+        if wrapper:
+            if isinstance(wrapper, str):
+                return Div(fieldset, cls=wrapper)
+            elif isinstance(wrapper, dict):
+                return Div(fieldset, **wrapper)
+        return fieldset
+
+    # =========================================================================
+    # Other Inputs
+    # =========================================================================
+
+    @staticmethod
+    def file(
+        name: str,
+        label: Optional[str] = None,
+        required: bool = False,
+        accept: Optional[str] = None,
+        multiple: bool = False,
+        wrapper: Optional[Union[str, Dict[str, Any]]] = None,
+        id: Optional[str] = None,
+        **attrs
+    ) -> HTMLElement:
+        """Create a file upload field.
+
+        Args:
+            name: Field name
+            label: Optional label text
+            required: Whether file selection is required
+            accept: Accepted file types (e.g., "image/*", ".pdf,.doc")
+            multiple: Allow multiple file selection
+            wrapper: Wrapper div class name or attributes dict
+            id: Custom id (defaults to name)
+        """
+        field_id = id or name
+        input_attrs = _filter_none(
+            type="file",
+            id=field_id,
+            name=name,
+            required=required if required else None,
+            accept=accept,
+            multiple=multiple if multiple else None,
+            **attrs
+        )
+        inp = Input(**input_attrs)
+        return _build_field(inp, name, label, wrapper, id)
+
+    @staticmethod
+    def hidden(
+        name: str,
+        value: str,
+        **attrs
+    ) -> HTMLElement:
+        """Create a hidden input field.
+
+        Args:
+            name: Field name
+            value: Hidden value
+        """
+        return Input(type="hidden", name=name, value=value, **attrs)
+
+    @staticmethod
+    def color(
+        name: str,
+        label: Optional[str] = None,
+        value: Optional[str] = None,
+        wrapper: Optional[Union[str, Dict[str, Any]]] = None,
+        id: Optional[str] = None,
+        **attrs
+    ) -> HTMLElement:
+        """Create a color picker field.
+
+        Args:
+            name: Field name
+            label: Optional label text
+            value: Default color in #RRGGBB format
+            wrapper: Wrapper div class name or attributes dict
+            id: Custom id (defaults to name)
+        """
+        field_id = id or name
+        input_attrs = _filter_none(
+            type="color",
+            id=field_id,
+            name=name,
+            value=value,
+            **attrs
+        )
+        inp = Input(**input_attrs)
+        return _build_field(inp, name, label, wrapper, id)
diff --git a/tests/test_forms.py b/tests/test_forms.py
new file mode 100644
index 0000000..d21d836
--- /dev/null
+++ b/tests/test_forms.py
@@ -0,0 +1,444 @@
+import unittest
+
+from nitro_ui import Field, Form, Button
+from nitro_ui.core.fragment import Fragment
+from nitro_ui.tags.layout import Div
+
+
+class TestFieldText(unittest.TestCase):
+    """Test text input fields."""
+
+    def test_text_basic(self):
+        """Test basic text field."""
+        field = Field.text("username")
+        rendered = str(field)
+        self.assertIn('type="text"', rendered)
+        self.assertIn('id="username"', rendered)
+        self.assertIn('name="username"', rendered)
+
+    def test_text_with_label(self):
+        """Test text field with label."""
+        field = Field.text("username", label="Username")
+        rendered = str(field)
+        self.assertIn('<label for="username">Username</label>', rendered)
+        self.assertIn('<input', rendered)
+
+    def test_text_required(self):
+        """Test required text field."""
+        field = Field.text("username", required=True)
+        self.assertIn('required', str(field))
+
+    def test_text_min_max_length(self):
+        """Test text field with length constraints."""
+        field = Field.text("username", min_length=3, max_length=20)
+        rendered = str(field)
+        self.assertIn('minlength="3"', rendered)
+        self.assertIn('maxlength="20"', rendered)
+
+    def test_text_pattern(self):
+        """Test text field with pattern."""
+        field = Field.text("username", pattern="[a-z]+")
+        self.assertIn('pattern="[a-z]+"', str(field))
+
+    def test_text_placeholder(self):
+        """Test text field with placeholder."""
+        field = Field.text("username", placeholder="Enter username")
+        self.assertIn('placeholder="Enter username"', str(field))
+
+    def test_text_value(self):
+        """Test text field with default value."""
+        field = Field.text("username", value="john")
+        self.assertIn('value="john"', str(field))
+
+    def test_text_custom_id(self):
+        """Test text field with custom id."""
+        field = Field.text("user_name", id="username-input", label="Username")
+        rendered = str(field)
+        self.assertIn('id="username-input"', rendered)
+        self.assertIn('name="user_name"', rendered)
+        self.assertIn('for="username-input"', rendered)
+
+
+class TestFieldEmail(unittest.TestCase):
+    """Test email input fields."""
+
+    def test_email_basic(self):
+        """Test basic email field."""
+        field = Field.email("email")
+        rendered = str(field)
+        self.assertIn('type="email"', rendered)
+        self.assertIn('name="email"', rendered)
+
+    def test_email_with_all_options(self):
+        """Test email field with all options."""
+        field = Field.email("email", label="Email", required=True, placeholder="you@example.com")
+        rendered = str(field)
+        self.assertIn('<label for="email">Email</label>', rendered)
+        self.assertIn('type="email"', rendered)
+        self.assertIn('required', rendered)
+        self.assertIn('placeholder="you@example.com"', rendered)
+
+
+class TestFieldPassword(unittest.TestCase):
+    """Test password input fields."""
+
+    def test_password_basic(self):
+        """Test basic password field."""
+        field = Field.password("password")
+        self.assertIn('type="password"', str(field))
+
+    def test_password_min_length(self):
+        """Test password field with min length."""
+        field = Field.password("password", min_length=8)
+        self.assertIn('minlength="8"', str(field))
+
+
+class TestFieldUrl(unittest.TestCase):
+    """Test URL input fields."""
+
+    def test_url_basic(self):
+        """Test basic URL field."""
+        field = Field.url("website")
+        self.assertIn('type="url"', str(field))
+
+
+class TestFieldTel(unittest.TestCase):
+    """Test telephone input fields."""
+
+    def test_tel_basic(self):
+        """Test basic tel field."""
+        field = Field.tel("phone")
+        self.assertIn('type="tel"', str(field))
+
+    def test_tel_pattern(self):
+        """Test tel field with pattern."""
+        field = Field.tel("phone", pattern="[0-9]{3}-[0-9]{4}")
+        self.assertIn('pattern="[0-9]{3}-[0-9]{4}"', str(field))
+
+
+class TestFieldSearch(unittest.TestCase):
+    """Test search input fields."""
+
+    def test_search_basic(self):
+        """Test basic search field."""
+        field = Field.search("q")
+        self.assertIn('type="search"', str(field))
+
+
+class TestFieldTextarea(unittest.TestCase):
+    """Test textarea fields."""
+
+    def test_textarea_basic(self):
+        """Test basic textarea."""
+        field = Field.textarea("message")
+        rendered = str(field)
+        self.assertIn('<textarea', rendered)
+        self.assertIn('name="message"', rendered)
+
+    def test_textarea_rows_cols(self):
+        """Test textarea with rows and cols."""
+        field = Field.textarea("message", rows=5, cols=40)
+        rendered = str(field)
+        self.assertIn('rows="5"', rendered)
+        self.assertIn('cols="40"', rendered)
+
+    def test_textarea_value(self):
+        """Test textarea with default value."""
+        field = Field.textarea("message", value="Hello world")
+        self.assertIn('Hello world', str(field))
+
+
+class TestFieldNumber(unittest.TestCase):
+    """Test number input fields."""
+
+    def test_number_basic(self):
+        """Test basic number field."""
+        field = Field.number("age")
+        self.assertIn('type="number"', str(field))
+
+    def test_number_min_max(self):
+        """Test number field with min/max."""
+        field = Field.number("age", min=0, max=120)
+        rendered = str(field)
+        self.assertIn('min="0"', rendered)
+        self.assertIn('max="120"', rendered)
+
+    def test_number_step(self):
+        """Test number field with step."""
+        field = Field.number("price", step=0.01)
+        self.assertIn('step="0.01"', str(field))
+
+
+class TestFieldRange(unittest.TestCase):
+    """Test range input fields."""
+
+    def test_range_basic(self):
+        """Test basic range field."""
+        field = Field.range("volume")
+        rendered = str(field)
+        self.assertIn('type="range"', rendered)
+        self.assertIn('min="0"', rendered)
+        self.assertIn('max="100"', rendered)
+
+    def test_range_custom_min_max(self):
+        """Test range field with custom min/max."""
+        field = Field.range("brightness", min=1, max=10)
+        rendered = str(field)
+        self.assertIn('min="1"', rendered)
+        self.assertIn('max="10"', rendered)
+
+
+class TestFieldDate(unittest.TestCase):
+    """Test date input fields."""
+
+    def test_date_basic(self):
+        """Test basic date field."""
+        field = Field.date("birthdate")
+        self.assertIn('type="date"', str(field))
+
+    def test_date_min_max(self):
+        """Test date field with min/max."""
+        field = Field.date("birthdate", min="1900-01-01", max="2020-12-31")
+        rendered = str(field)
+        self.assertIn('min="1900-01-01"', rendered)
+        self.assertIn('max="2020-12-31"', rendered)
+
+
+class TestFieldTime(unittest.TestCase):
+    """Test time input fields."""
+
+    def test_time_basic(self):
+        """Test basic time field."""
+        field = Field.time("appointment")
+        self.assertIn('type="time"', str(field))
+
+
+class TestFieldDatetimeLocal(unittest.TestCase):
+    """Test datetime-local input fields."""
+
+    def test_datetime_local_basic(self):
+        """Test basic datetime-local field."""
+        field = Field.datetime_local("meeting")
+        self.assertIn('type="datetime-local"', str(field))
+
+
+class TestFieldSelect(unittest.TestCase):
+    """Test select fields."""
+
+    def test_select_string_options(self):
+        """Test select with string options."""
+        field = Field.select("country", ["USA", "Canada", "Mexico"])
+        rendered = str(field)
+        self.assertIn('<select', rendered)
+        self.assertIn('<option value="USA">USA</option>', rendered)
+        self.assertIn('<option value="Canada">Canada</option>', rendered)
+        self.assertIn('<option value="Mexico">Mexico</option>', rendered)
+
+    def test_select_tuple_options(self):
+        """Test select with tuple options."""
+        field = Field.select("status", [("active", "Active"), ("inactive", "Inactive")])
+        rendered = str(field)
+        self.assertIn('<option value="active">Active</option>', rendered)
+        self.assertIn('<option value="inactive">Inactive</option>', rendered)
+
+    def test_select_dict_options(self):
+        """Test select with dict options."""
+        field = Field.select("priority", [
+            {"value": "1", "label": "Low"},
+            {"value": "2", "label": "High", "disabled": True}
+        ])
+        rendered = str(field)
+        self.assertIn('<option value="1">Low</option>', rendered)
+        self.assertIn('disabled', rendered)
+
+    def test_select_with_value(self):
+        """Test select with pre-selected value."""
+        field = Field.select("country", ["USA", "Canada"], value="Canada")
+        self.assertIn('selected', str(field))
+
+    def test_select_with_label(self):
+        """Test select with label."""
+        field = Field.select("country", ["USA", "Canada"], label="Country")
+        rendered = str(field)
+        self.assertIn('<label for="country">Country</label>', rendered)
+
+
+class TestFieldCheckbox(unittest.TestCase):
+    """Test checkbox fields."""
+
+    def test_checkbox_basic(self):
+        """Test basic checkbox."""
+        field = Field.checkbox("subscribe")
+        rendered = str(field)
+        self.assertIn('type="checkbox"', rendered)
+        self.assertIn('name="subscribe"', rendered)
+        self.assertIn('value="on"', rendered)
+
+    def test_checkbox_checked(self):
+        """Test checked checkbox."""
+        field = Field.checkbox("subscribe", checked=True)
+        self.assertIn('checked', str(field))
+
+    def test_checkbox_with_label(self):
+        """Test checkbox with label wrapping input."""
+        field = Field.checkbox("subscribe", label="Subscribe to newsletter")
+        rendered = str(field)
+        self.assertIn('<label>', rendered)
+        self.assertIn('Subscribe to newsletter', rendered)
+        # Label wraps input, with input first
+        self.assertIn('<label><input', rendered)
+        self.assertIn('</label>', rendered)
+
+    def test_checkbox_custom_value(self):
+        """Test checkbox with custom value."""
+        field = Field.checkbox("agree", value="yes")
+        self.assertIn('value="yes"', str(field))
+
+    def test_checkbox_required(self):
+        """Test required checkbox."""
+        field = Field.checkbox("terms", required=True)
+        self.assertIn('required', str(field))
+
+
+class TestFieldRadio(unittest.TestCase):
+    """Test radio button fields."""
+
+    def test_radio_basic(self):
+        """Test basic radio buttons."""
+        field = Field.radio("plan", [("free", "Free"), ("pro", "Pro")])
+        rendered = str(field)
+        self.assertIn('<fieldset', rendered)
+        self.assertIn('type="radio"', rendered)
+        self.assertIn('name="plan"', rendered)
+        self.assertIn('value="free"', rendered)
+        self.assertIn('value="pro"', rendered)
+
+    def test_radio_with_legend(self):
+        """Test radio buttons with legend."""
+        field = Field.radio("plan", [("free", "Free")], label="Select Plan")
+        rendered = str(field)
+        self.assertIn('<legend>Select Plan</legend>', rendered)
+
+    def test_radio_with_value(self):
+        """Test radio buttons with pre-selected value."""
+        field = Field.radio("plan", [("free", "Free"), ("pro", "Pro")], value="pro")
+        # The pro option should be checked
+        self.assertIn('checked', str(field))
+
+
+class TestFieldFile(unittest.TestCase):
+    """Test file input fields."""
+
+    def test_file_basic(self):
+        """Test basic file field."""
+        field = Field.file("document")
+        self.assertIn('type="file"', str(field))
+
+    def test_file_accept(self):
+        """Test file field with accept."""
+        field = Field.file("image", accept="image/*")
+        self.assertIn('accept="image/*"', str(field))
+
+    def test_file_multiple(self):
+        """Test file field with multiple."""
+        field = Field.file("documents", multiple=True)
+        self.assertIn('multiple', str(field))
+
+
+class TestFieldHidden(unittest.TestCase):
+    """Test hidden input fields."""
+
+    def test_hidden_basic(self):
+        """Test basic hidden field."""
+        field = Field.hidden("csrf_token", "abc123")
+        rendered = str(field)
+        self.assertIn('type="hidden"', rendered)
+        self.assertIn('name="csrf_token"', rendered)
+        self.assertIn('value="abc123"', rendered)
+
+
+class TestFieldColor(unittest.TestCase):
+    """Test color input fields."""
+
+    def test_color_basic(self):
+        """Test basic color field."""
+        field = Field.color("theme_color")
+        self.assertIn('type="color"', str(field))
+
+    def test_color_with_value(self):
+        """Test color field with default value."""
+        field = Field.color("theme_color", value="#ff0000")
+        self.assertIn('value="#ff0000"', str(field))
+
+
+class TestFieldWrapper(unittest.TestCase):
+    """Test wrapper functionality."""
+
+    def test_wrapper_string(self):
+        """Test wrapper with string class name."""
+        field = Field.text("username", label="Username", wrapper="form-field")
+        rendered = str(field)
+        self.assertIn('<div class="form-field">', rendered)
+        self.assertIn('<label', rendered)
+        self.assertIn('<input', rendered)
+        self.assertIn('</div>', rendered)
+
+    def test_wrapper_dict(self):
+        """Test wrapper with dict attributes."""
+        field = Field.text("username", label="Username", wrapper={"cls": "form-group", "id": "username-field"})
+        rendered = str(field)
+        self.assertIn('class="form-group"', rendered)
+        self.assertIn('id="username-field"', rendered)
+
+    def test_no_label_no_wrapper(self):
+        """Test field without label or wrapper returns just input."""
+        field = Field.text("username")
+        rendered = str(field)
+        self.assertTrue(rendered.startswith('<input'))
+        self.assertNotIn('<div', rendered)
+        self.assertNotIn('<label', rendered)
+
+
+class TestFieldExtraAttrs(unittest.TestCase):
+    """Test extra HTML attributes."""
+
+    def test_extra_attrs(self):
+        """Test passing extra attributes."""
+        field = Field.text("username", autocomplete="off", data_validate="true")
+        rendered = str(field)
+        self.assertIn('autocomplete="off"', rendered)
+        self.assertIn('data-validate="true"', rendered)
+
+    def test_htmx_attrs(self):
+        """Test HTMX attributes work with fields."""
+        field = Field.text("search", hx_get="/search", hx_trigger="keyup changed delay:300ms")
+        rendered = str(field)
+        self.assertIn('hx-get="/search"', rendered)
+        self.assertIn('hx-trigger="keyup changed delay:300ms"', rendered)
+
+
+class TestFieldInForm(unittest.TestCase):
+    """Test fields composing in forms."""
+
+    def test_complete_form(self):
+        """Test building a complete form with fields."""
+        form = Form(
+            Field.email("email", label="Email", required=True),
+            Field.password("password", label="Password", min_length=8),
+            Field.checkbox("remember", label="Remember me"),
+            Button("Log In", type="submit"),
+            action="/login",
+            method="post"
+        )
+        rendered = str(form)
+        self.assertIn('<form', rendered)
+        self.assertIn('action="/login"', rendered)
+        self.assertIn('method="post"', rendered)
+        self.assertIn('type="email"', rendered)
+        self.assertIn('type="password"', rendered)
+        self.assertIn('type="checkbox"', rendered)
+        self.assertIn('<button', rendered)
+
+
+if __name__ == "__main__":
+    unittest.main()
diff --git a/tests/test_htmx.py b/tests/test_htmx.py
new file mode 100644
index 0000000..409d9f8
--- /dev/null
+++ b/tests/test_htmx.py
@@ -0,0 +1,174 @@
+import unittest
+
+from nitro_ui import Button, Div, Form, Input, Span
+from nitro_ui.tags.text import Href
+
+
+class TestHTMXAttributes(unittest.TestCase):
+    """Test that HTMX attributes work correctly with NitroUI."""
+
+    def test_hx_get(self):
+        """Test hx-get attribute."""
+        btn = Button("Load", hx_get="/items")
+        self.assertIn('hx-get="/items"', str(btn))
+
+    def test_hx_post(self):
+        """Test hx-post attribute."""
+        btn = Button("Submit", hx_post="/submit")
+        self.assertIn('hx-post="/submit"', str(btn))
+
+    def test_hx_put(self):
+        """Test hx-put attribute."""
+        btn = Button("Update", hx_put="/items/1")
+        self.assertIn('hx-put="/items/1"', str(btn))
+
+    def test_hx_patch(self):
+        """Test hx-patch attribute."""
+        btn = Button("Patch", hx_patch="/items/1")
+        self.assertIn('hx-patch="/items/1"', str(btn))
+
+    def test_hx_delete(self):
+        """Test hx-delete attribute."""
+        btn = Button("Delete", hx_delete="/items/1")
+        self.assertIn('hx-delete="/items/1"', str(btn))
+
+    def test_hx_target(self):
+        """Test hx-target attribute."""
+        btn = Button("Load", hx_get="/items", hx_target="#list")
+        self.assertIn('hx-target="#list"', str(btn))
+
+    def test_hx_swap(self):
+        """Test hx-swap attribute."""
+        btn = Button("Load", hx_get="/items", hx_swap="outerHTML")
+        self.assertIn('hx-swap="outerHTML"', str(btn))
+
+    def test_hx_trigger(self):
+        """Test hx-trigger attribute."""
+        inp = Input(type="text", hx_get="/search", hx_trigger="keyup changed delay:500ms")
+        self.assertIn('hx-trigger="keyup changed delay:500ms"', str(inp))
+
+    def test_hx_confirm(self):
+        """Test hx-confirm attribute."""
+        btn = Button("Delete", hx_delete="/items/1", hx_confirm="Are you sure?")
+        self.assertIn('hx-confirm="Are you sure?"', str(btn))
+
+    def test_hx_indicator(self):
+        """Test hx-indicator attribute."""
+        btn = Button("Load", hx_get="/items", hx_indicator="#spinner")
+        self.assertIn('hx-indicator="#spinner"', str(btn))
+
+    def test_hx_push_url(self):
+        """Test hx-push-url attribute."""
+        link = Href("Page 2", href="#", hx_get="/page/2", hx_push_url="true")
+        self.assertIn('hx-push-url="true"', str(link))
+
+    def test_hx_select(self):
+        """Test hx-select attribute."""
+        btn = Button("Load", hx_get="/items", hx_select="#content")
+        self.assertIn('hx-select="#content"', str(btn))
+
+    def test_hx_select_oob(self):
+        """Test hx-select-oob attribute."""
+        btn = Button("Load", hx_get="/items", hx_select_oob="#sidebar")
+        self.assertIn('hx-select-oob="#sidebar"', str(btn))
+
+    def test_hx_swap_oob(self):
+        """Test hx-swap-oob attribute."""
+        div = Div("Updated", id="notification", hx_swap_oob="true")
+        self.assertIn('hx-swap-oob="true"', str(div))
+
+    def test_hx_vals(self):
+        """Test hx-vals attribute with JSON."""
+        btn = Button("Submit", hx_post="/submit", hx_vals='{"key": "value"}')
+        self.assertIn('hx-vals="{&quot;key&quot;: &quot;value&quot;}"', str(btn))
+
+    def test_hx_boost(self):
+        """Test hx-boost attribute."""
+        link = Href("About", href="/about", hx_boost="true")
+        self.assertIn('hx-boost="true"', str(link))
+
+    def test_hx_include(self):
+        """Test hx-include attribute."""
+        btn = Button("Submit", hx_post="/submit", hx_include="[name='csrf']")
+        self.assertIn('hx-include="[name=', str(btn))
+
+    def test_hx_params(self):
+        """Test hx-params attribute."""
+        btn = Button("Submit", hx_post="/submit", hx_params="*")
+        self.assertIn('hx-params="*"', str(btn))
+
+    def test_hx_preserve(self):
+        """Test hx-preserve attribute."""
+        inp = Input(type="text", id="search", hx_preserve="true")
+        self.assertIn('hx-preserve="true"', str(inp))
+
+    def test_hx_disable(self):
+        """Test hx-disable attribute."""
+        btn = Button("Submit", hx_post="/submit", hx_disable="true")
+        self.assertIn('hx-disable="true"', str(btn))
+
+    def test_multiple_hx_attributes(self):
+        """Test multiple HTMX attributes together."""
+        btn = Button(
+            "Load More",
+            hx_get="/items",
+            hx_target="#list",
+            hx_swap="beforeend",
+            hx_indicator="#spinner"
+        )
+        rendered = str(btn)
+        self.assertIn('hx-get="/items"', rendered)
+        self.assertIn('hx-target="#list"', rendered)
+        self.assertIn('hx-swap="beforeend"', rendered)
+        self.assertIn('hx-indicator="#spinner"', rendered)
+
+    def test_hx_with_other_attributes(self):
+        """Test HTMX attributes alongside regular HTML attributes."""
+        btn = Button(
+            "Delete",
+            id="delete-btn",
+            cls="btn btn-danger",
+            hx_delete="/items/1",
+            hx_confirm="Are you sure?",
+            disabled=True
+        )
+        rendered = str(btn)
+        self.assertIn('id="delete-btn"', rendered)
+        self.assertIn('class="btn btn-danger"', rendered)
+        self.assertIn('hx-delete="/items/1"', rendered)
+        self.assertIn('hx-confirm="Are you sure?"', rendered)
+
+    def test_form_with_htmx(self):
+        """Test form with HTMX attributes."""
+        form = Form(
+            Input(type="text", name="query", hx_get="/search", hx_trigger="keyup changed delay:300ms", hx_target="#results"),
+            Div(id="results"),
+            hx_boost="true"
+        )
+        rendered = str(form)
+        self.assertIn('hx-boost="true"', rendered)
+        self.assertIn('hx-get="/search"', rendered)
+        self.assertIn('hx-trigger="keyup changed delay:300ms"', rendered)
+
+
+class TestHTMXExtensions(unittest.TestCase):
+    """Test HTMX extension attributes."""
+
+    def test_hx_ext(self):
+        """Test hx-ext attribute for extensions."""
+        div = Div(hx_ext="json-enc")
+        self.assertIn('hx-ext="json-enc"', str(div))
+
+    def test_sse_connect(self):
+        """Test SSE extension attributes."""
+        div = Div(hx_ext="sse", sse_connect="/events")
+        self.assertIn('sse-connect="/events"', str(div))
+
+    def test_ws_connect(self):
+        """Test WebSocket extension attributes."""
+        div = Div(hx_ext="ws", ws_connect="/ws")
+        self.assertIn('ws-connect="/ws"', str(div))
+
+
+if __name__ == "__main__":
+    unittest.main()