diff --git a/cot-core/src/html.rs b/cot-core/src/html.rs
index bdbd8ce9..7264d59d 100644
--- a/cot-core/src/html.rs
+++ b/cot-core/src/html.rs
@@ -189,6 +189,37 @@ impl HtmlTag {
         input
     }
 
+    /// Creates a new `HtmlTag` instance for a datalist element.
+    ///
+    /// # Examples
+    /// ```
+    /// use cot::html::HtmlTag;
+    /// let data_list = HtmlTag::data_list(vec!["Option 1", "Option 2"], "my-datalist");
+    /// let rendered = data_list.render();
+    /// ```
+    #[must_use]
+    pub fn data_list<I, S>(list: I, id: &str) -> Self
+    where
+        I: IntoIterator<Item = S>,
+        S: AsRef<str>,
+    {
+        let mut data_list = Self::new("datalist");
+        data_list.attr("id", id);
+
+        let mut options: Vec<HtmlNode> = Vec::new();
+
+        for item in list {
+            let l = item.as_ref();
+            let mut option = HtmlTag::new("option");
+            option.attr("value", l);
+            option.push_str(l);
+            options.push(HtmlNode::Tag(option));
+        }
+
+        data_list.children = options;
+        data_list
+    }
+
     /// Adds an attribute to the HTML tag.
     ///
     /// # Safety
diff --git a/cot/src/form/fields.rs b/cot/src/form/fields.rs
index 1fcb4f14..8375bdcb 100644
--- a/cot/src/form/fields.rs
+++ b/cot/src/form/fields.rs
@@ -10,7 +10,7 @@ use std::num::{
 };
 
 use askama::filters::HtmlSafe;
-pub use attrs::Step;
+pub use attrs::{AutoCapitalize, AutoComplete, Dir, List, Step};
 pub use chrono::{
     DateField, DateFieldOptions, DateTimeField, DateTimeFieldOptions, DateTimeWithTimezoneField,
     DateTimeWithTimezoneFieldOptions, TimeField, TimeFieldOptions,
@@ -73,11 +73,39 @@ pub(crate) use impl_form_field;
 impl_form_field!(StringField, StringFieldOptions, "a string");
 
 /// Custom options for a [`StringField`].
-#[derive(Debug, Default, Copy, Clone)]
+#[derive(Debug, Default, Clone)]
 pub struct StringFieldOptions {
     /// The maximum length of the field. Used to set the `maxlength` attribute
     /// in the HTML input element.
     pub max_length: Option<u32>,
+    /// The minimum length of the field. Used to set the `minlength` attribute
+    /// in the HTML input element.
+    pub min_length: Option<u32>,
+    /// The size of the field. Used to set the `size` attribute in the HTML
+    /// input element.
+    pub size: Option<u32>,
+    /// Corresponds to  the [`AutoCapitalize`] attribute in the HTML input
+    /// element.
+    pub autocapitalize: Option<AutoCapitalize>,
+    /// Corresponds to the [`AutoComplete`] attribute in the HTML input element.
+    pub autocomplete: Option<AutoComplete>,
+    /// The direction of the text input, which can be set to `ltr`
+    /// (left-to-right) or `rtl` (right-to-left). This corresponds to the
+    /// [`Dir`] attribute in the HTML input element.
+    pub dir: Option<Dir>,
+    /// The [`dirname`] attribute in the HTML input element, which is used to
+    /// specify the direction of the text input.
+    ///
+    /// [`dirname`]: https://developer.mozilla.org/en-US/docs/Web/HTML/Reference/Elements/input#dirname
+    pub dirname: Option<String>,
+    /// A [`List`] of options for the `datalist` element, which can be used to
+    /// provide predefined options for the input.
+    pub list: Option<List>,
+    /// The placeholder text for the input field, which is displayed when the
+    /// field is empty.
+    pub placeholder: Option<String>,
+    /// If `true`, the field is read-only and cannot be modified by the user.
+    pub readonly: Option<bool>,
 }
 
 impl Display for StringField {
@@ -91,6 +119,42 @@ impl Display for StringField {
         if let Some(max_length) = self.custom_options.max_length {
             tag.attr("maxlength", max_length.to_string());
         }
+        if let Some(min_length) = self.custom_options.min_length {
+            tag.attr("minlength", min_length.to_string());
+        }
+
+        if let Some(placeholder) = &self.custom_options.placeholder {
+            tag.attr("placeholder", placeholder);
+        }
+        if let Some(readonly) = self.custom_options.readonly
+            && readonly
+        {
+            tag.bool_attr("readonly");
+        }
+        if let Some(autocomplete) = &self.custom_options.autocomplete {
+            tag.attr("autocomplete", autocomplete.to_string());
+        }
+
+        if let Some(size) = self.custom_options.size {
+            tag.attr("size", size.to_string());
+        }
+
+        if let Some(dir) = &self.custom_options.dir {
+            tag.attr("dir", dir.as_str());
+        }
+
+        if let Some(dirname) = &self.custom_options.dirname {
+            tag.attr("dirname", dirname);
+        }
+
+        if let Some(list) = &self.custom_options.list {
+            let list_id = format!("__{}_datalist", self.id());
+            tag.attr("list", &list_id);
+
+            let data_list = HtmlTag::data_list(list.clone(), &list_id);
+            tag.push_tag(data_list);
+        }
+
         if let Some(value) = &self.value {
             tag.attr("value", value);
         }
@@ -143,11 +207,26 @@ impl<const LEN: u32> AsFormField for LimitedString<LEN> {
 impl_form_field!(PasswordField, PasswordFieldOptions, "a password");
 
 /// Custom options for a [`PasswordField`].
-#[derive(Debug, Default, Copy, Clone)]
+#[derive(Debug, Default, Clone)]
 pub struct PasswordFieldOptions {
     /// The maximum length of the field. Used to set the `maxlength` attribute
     /// in the HTML input element.
     pub max_length: Option<u32>,
+    /// The minimum length of the field. Used to set the `minlength` attribute
+    /// in the HTML input element.
+    pub min_length: Option<u32>,
+    /// The size of the field. Used to set the [`size`] attribute in the HTML
+    /// input element.
+    ///
+    /// [`size`]: https://developer.mozilla.org/en-US/docs/Web/HTML/Reference/Elements/input#size
+    pub size: Option<u32>,
+    /// Corresponds to the [`AutoComplete`] attribute in the HTML input element.
+    pub autocomplete: Option<AutoComplete>,
+    /// The placeholder text for the input field, which is displayed when the
+    /// field is empty.
+    pub placeholder: Option<String>,
+    /// If `true`, the field is read-only and cannot be modified by the user.
+    pub readonly: Option<bool>,
 }
 
 impl Display for PasswordField {
@@ -161,6 +240,26 @@ impl Display for PasswordField {
         if let Some(max_length) = self.custom_options.max_length {
             tag.attr("maxlength", max_length.to_string());
         }
+
+        if let Some(min_length) = self.custom_options.min_length {
+            tag.attr("minlength", min_length.to_string());
+        }
+        if let Some(placeholder) = &self.custom_options.placeholder {
+            tag.attr("placeholder", placeholder);
+        }
+        if let Some(readonly) = self.custom_options.readonly
+            && readonly
+        {
+            tag.bool_attr("readonly");
+        }
+        if let Some(autocomplete) = &self.custom_options.autocomplete {
+            tag.attr("autocomplete", autocomplete.to_string());
+        }
+
+        if let Some(size) = self.custom_options.size {
+            tag.attr("size", size.to_string());
+        }
+
         // we don't set the value attribute for password fields
         // to avoid leaking the password in the HTML
 
@@ -218,7 +317,7 @@ impl AsFormField for PasswordHash {
 impl_form_field!(EmailField, EmailFieldOptions, "an email");
 
 /// Custom options for [`EmailField`]
-#[derive(Debug, Default, Copy, Clone)]
+#[derive(Debug, Default, Clone)]
 pub struct EmailFieldOptions {
     /// The maximum length of the field used to set the `maxlength` attribute
     /// in the HTML input element.
@@ -226,11 +325,38 @@ pub struct EmailFieldOptions {
     /// The minimum length of the field used to set the `minlength` attribute
     /// in the HTML input element.
     pub min_length: Option<u32>,
+    /// The size of the field used to set the [`size`] attribute in the HTML
+    /// input element.
+    ///
+    /// [`size`]: https://developer.mozilla.org/en-US/docs/Web/HTML/Reference/Elements/input#size
+    pub size: Option<u32>,
+    /// Corresponds to the [`AutoCapitalize`] attribute in the HTML input
+    /// element.
+    pub autocomplete: Option<AutoComplete>,
+    /// The direction of the text input, which can be set to `ltr`
+    /// (left-to-right) or `rtl` (right-to-left). This corresponds to the
+    /// [`Dir`] attribute in the HTML input element.
+    pub dir: Option<Dir>,
+    /// The [`dirname`] attribute in the HTML input element, which is used to
+    /// specify the direction of the text input.
+    ///
+    /// [`dirname`]: https://developer.mozilla.org/en-US/docs/Web/HTML/Reference/Elements/input#dirname
+    pub dirname: Option<String>,
+    /// A [`List`] of options for the `datalist` element, which can be used to
+    /// provide predefined options for the input.
+    pub list: Option<List>,
+    /// The placeholder text for the input field, which is displayed when the
+    /// field is empty.
+    pub placeholder: Option<String>,
+    /// If `true`, the field is read-only and cannot be modified by the user.
+    pub readonly: Option<bool>,
 }
 
 impl Display for EmailField {
     fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
         let mut tag = HtmlTag::input("email");
+        let mut data_list: Option<HtmlTag> = None;
+
         tag.attr("name", self.id());
         tag.attr("id", self.id());
         if self.options.required {
@@ -242,10 +368,49 @@ impl Display for EmailField {
         if let Some(min_length) = self.custom_options.min_length {
             tag.attr("minlength", min_length.to_string());
         }
+        if let Some(placeholder) = &self.custom_options.placeholder {
+            tag.attr("placeholder", placeholder);
+        }
+        if let Some(readonly) = self.custom_options.readonly
+            && readonly
+        {
+            tag.bool_attr("readonly");
+        }
+        if let Some(autocomplete) = &self.custom_options.autocomplete {
+            tag.attr("autocomplete", autocomplete.to_string());
+        }
+
+        if let Some(size) = self.custom_options.size {
+            tag.attr("size", size.to_string());
+        }
+
+        if let Some(dir) = &self.custom_options.dir {
+            tag.attr("dir", dir.as_str());
+        }
+
+        if let Some(dirname) = &self.custom_options.dirname {
+            tag.attr("dirname", dirname);
+        }
+
+        if let Some(list) = &self.custom_options.list {
+            let list_id = format!("__{}_datalist", self.id());
+            tag.attr("list", &list_id);
+
+            data_list = Some(HtmlTag::data_list(list.clone(), &list_id));
+        }
+
         if let Some(value) = &self.value {
             tag.attr("value", value);
         }
 
+        if let Some(data_list) = data_list {
+            let mut wrapper = HtmlTag::new("div");
+            wrapper
+                .attr("id", format!("__{}_datalist_wrapper", self.id()))
+                .push_tag(tag)
+                .push_tag(data_list);
+            return write!(f, "{}", wrapper.render());
+        }
         write!(f, "{}", tag.render())
     }
 }
@@ -290,10 +455,10 @@ impl AsFormField for Email {
 
 impl HtmlSafe for EmailField {}
 
-impl_form_field!(IntegerField, IntegerFieldOptions, "an integer", T: Integer);
+impl_form_field!(IntegerField, IntegerFieldOptions, "an integer", T: Integer + Display);
 
 /// Custom options for a [`IntegerField`].
-#[derive(Debug, Copy, Clone)]
+#[derive(Debug, Clone)]
 pub struct IntegerFieldOptions<T> {
     /// The minimum value of the field. Used to set the `min` attribute in the
     /// HTML input element.
@@ -301,6 +466,14 @@ pub struct IntegerFieldOptions<T> {
     /// The maximum value of the field. Used to set the `max` attribute in the
     /// HTML input element.
     pub max: Option<T>,
+    /// The placeholder text for the input field, which is displayed when the
+    /// field is empty.
+    pub placeholder: Option<String>,
+    /// If `true`, the field is read-only and cannot be modified by the user.
+    pub readonly: Option<bool>,
+    /// The step size for the field. Used to set the [`Step`] attribute in the
+    /// HTML input element.
+    pub step: Option<Step<T>>,
 }
 
 impl<T: Integer> Default for IntegerFieldOptions<T> {
@@ -308,11 +481,14 @@ impl<T: Integer> Default for IntegerFieldOptions<T> {
         Self {
             min: T::MIN,
             max: T::MAX,
+            placeholder: None,
+            readonly: None,
+            step: None,
         }
     }
 }
 
-impl<T: Integer> Display for IntegerField<T> {
+impl<T: Integer + Display> Display for IntegerField<T> {
     fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
         let mut tag = HtmlTag::input("number");
         tag.attr("name", self.id());
@@ -326,6 +502,19 @@ impl<T: Integer> Display for IntegerField<T> {
         if let Some(max) = &self.custom_options.max {
             tag.attr("max", max.to_string());
         }
+
+        if let Some(placeholder) = &self.custom_options.placeholder {
+            tag.attr("placeholder", placeholder);
+        }
+        if let Some(readonly) = self.custom_options.readonly
+            && readonly
+        {
+            tag.bool_attr("readonly");
+        }
+        if let Some(step) = &self.custom_options.step {
+            tag.attr("step", step.to_string());
+        }
+
         if let Some(value) = &self.value {
             tag.attr("value", value);
         }
@@ -334,7 +523,7 @@ impl<T: Integer> Display for IntegerField<T> {
     }
 }
 
-impl<T: Integer> HtmlSafe for IntegerField<T> {}
+impl<T: Integer + Display> HtmlSafe for IntegerField<T> {}
 
 /// A trait for numerical types that optionally have minimum and maximum values.
 ///
@@ -647,10 +836,10 @@ pub(crate) fn check_required<T: FormField>(field: &T) -> Result<&str, FormFieldV
     }
 }
 
-impl_form_field!(FloatField, FloatFieldOptions, "a float",  T: Float);
+impl_form_field!(FloatField, FloatFieldOptions, "a float",  T: Float + Display);
 
 /// Custom options for a [`FloatField`].
-#[derive(Debug, Copy, Clone)]
+#[derive(Debug, Clone)]
 pub struct FloatFieldOptions<T> {
     /// The minimum value of the field. Used to set the `min` attribute in the
     /// HTML input element.
@@ -658,6 +847,14 @@ pub struct FloatFieldOptions<T> {
     /// The maximum value of the field. Used to set the `max` attribute in the
     /// HTML input element.
     pub max: Option<T>,
+    /// The placeholder text for the input field, which is displayed when the
+    /// field is empty.
+    pub placeholder: Option<String>,
+    /// If `true`, the field is read-only and cannot be modified by the user.
+    pub readonly: Option<bool>,
+    /// The step size for the field. Used to set the [`Step`] attribute in the
+    /// HTML input element.
+    pub step: Option<Step<T>>,
 }
 
 impl<T: Float> Default for FloatFieldOptions<T> {
@@ -665,11 +862,14 @@ impl<T: Float> Default for FloatFieldOptions<T> {
         Self {
             min: T::MIN,
             max: T::MAX,
+            placeholder: None,
+            readonly: None,
+            step: None,
         }
     }
 }
 
-impl<T: Float> Display for FloatField<T> {
+impl<T: Float + Display> Display for FloatField<T> {
     fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
         let mut tag: HtmlTag = HtmlTag::input("number");
         tag.attr("name", self.id());
@@ -684,6 +884,17 @@ impl<T: Float> Display for FloatField<T> {
         if let Some(max) = &self.custom_options.max {
             tag.attr("max", max.to_string());
         }
+        if let Some(placeholder) = &self.custom_options.placeholder {
+            tag.attr("placeholder", placeholder);
+        }
+        if let Some(readonly) = self.custom_options.readonly
+            && readonly
+        {
+            tag.bool_attr("readonly");
+        }
+        if let Some(step) = &self.custom_options.step {
+            tag.attr("step", step.to_string());
+        }
         if let Some(value) = &self.value {
             tag.attr("value", value);
         }
@@ -692,7 +903,7 @@ impl<T: Float> Display for FloatField<T> {
     }
 }
 
-impl<T: Float> HtmlSafe for FloatField<T> {}
+impl<T: Float + Display> HtmlSafe for FloatField<T> {}
 
 /// A trait for types that can be represented as a float.
 ///
@@ -777,19 +988,86 @@ impl_float_as_form_field!(f64);
 impl_form_field!(UrlField, UrlFieldOptions, "a URL");
 
 /// Custom options for a [`UrlField`].
-#[derive(Debug, Default, Copy, Clone)]
-pub struct UrlFieldOptions;
+#[derive(Debug, Default, Clone)]
+pub struct UrlFieldOptions {
+    /// The maximum length of the field. Used to set the `maxlength` attribute
+    /// in the HTML input element.
+    pub max_length: Option<u32>,
+    /// The minimum length of the field. Used to set the `minlength` attribute
+    /// in the HTML input element.
+    pub min_length: Option<u32>,
+    /// The size of the field. Used to set the [`size`]attribute in the HTML
+    /// input element.
+    ///
+    /// [`size`]: https://developer.mozilla.org/en-US/docs/Web/HTML/Reference/Elements/input#size
+    pub size: Option<u32>,
+    /// The [`List`] of options for the `datalist` element, which can be used to
+    /// provide predefined options for the input.
+    pub list: Option<List>,
+    /// The direction of the text input, which can be set to `ltr`
+    /// (left-to-right) or `rtl` (right-to-left). This corresponds to the
+    /// [`Dir`] attribute in the HTML input element.
+    pub dir: Option<Dir>,
+    /// The [`dirname`] attribute in the HTML input element, which is used to
+    /// specify the direction of the text input.
+    ///
+    /// [`dirname`]: https://developer.mozilla.org/en-US/docs/Web/HTML/Reference/Elements/input#dirname
+    pub dirname: Option<String>,
+    /// The [`AutoComplete`] attribute in the HTML input element, which is used
+    /// to specify how the browser should handle autocomplete for the input.
+    pub autocomplete: Option<AutoComplete>,
+    /// The placeholder text for the input field, which is displayed when the
+    /// field is empty.
+    pub placeholder: Option<String>,
+    /// If `true`, the field is read-only and cannot be modified by the user.
+    pub readonly: Option<bool>,
+}
 
 impl Display for UrlField {
     fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
-        // no custom options
-        let _ = self.custom_options;
         let mut tag = HtmlTag::input("url");
         tag.attr("name", self.id());
         tag.attr("id", self.id());
         if self.options.required {
             tag.bool_attr("required");
         }
+        if let Some(max_length) = self.custom_options.max_length {
+            tag.attr("maxlength", max_length.to_string());
+        }
+        if let Some(min_length) = self.custom_options.min_length {
+            tag.attr("minlength", min_length.to_string());
+        }
+        if let Some(placeholder) = &self.custom_options.placeholder {
+            tag.attr("placeholder", placeholder);
+        }
+        if let Some(readonly) = self.custom_options.readonly
+            && readonly
+        {
+            tag.bool_attr("readonly");
+        }
+        if let Some(autocomplete) = &self.custom_options.autocomplete {
+            tag.attr("autocomplete", autocomplete.to_string());
+        }
+
+        if let Some(size) = self.custom_options.size {
+            tag.attr("size", size.to_string());
+        }
+
+        if let Some(dir) = &self.custom_options.dir {
+            tag.attr("dir", dir.as_str());
+        }
+
+        if let Some(dirname) = &self.custom_options.dirname {
+            tag.attr("dirname", dirname);
+        }
+
+        if let Some(list) = &self.custom_options.list {
+            let list_id = format!("__{}_datalist", self.id());
+            tag.attr("list", &list_id);
+
+            let data_list = HtmlTag::data_list(list, &list_id);
+            tag.push_tag(data_list);
+        }
         if let Some(value) = &self.value {
             tag.attr("value", value);
         }
@@ -832,12 +1110,30 @@ mod tests {
             },
             StringFieldOptions {
                 max_length: Some(10),
+                min_length: Some(5),
+                size: Some(15),
+                autocapitalize: Some(AutoCapitalize::Words),
+                autocomplete: Some(AutoComplete::Value("foo bar".to_string())),
+                dir: Some(Dir::Ltr),
+                dirname: Some("dir".to_string()),
+                list: Some(List::new(["bar", "baz"])),
+                placeholder: Some("Enter text".to_string()),
+                readonly: Some(true),
             },
         );
         let html = field.to_string();
         assert!(html.contains("type=\"text\""));
+        assert!(html.contains("name=\"test\""));
+        assert!(html.contains("id=\"test\""));
         assert!(html.contains("required"));
         assert!(html.contains("maxlength=\"10\""));
+        assert!(html.contains("minlength=\"5\""));
+        assert!(html.contains("size=\"15\""));
+        assert!(html.contains("autocomplete=\"foo bar\""));
+        assert!(html.contains("dir=\"ltr\""));
+        assert!(html.contains("dirname=\"dir\""));
+        assert!(html.contains("placeholder=\"Enter text\""));
+        assert!(html.contains("readonly"));
     }
 
     #[cot::test]
@@ -850,6 +1146,7 @@ mod tests {
             },
             StringFieldOptions {
                 max_length: Some(10),
+                ..Default::default()
             },
         );
         field
@@ -870,6 +1167,7 @@ mod tests {
             },
             StringFieldOptions {
                 max_length: Some(10),
+                ..Default::default()
             },
         );
         field.set_value(FormFieldValue::new_text("")).await.unwrap();
@@ -887,13 +1185,22 @@ mod tests {
             },
             PasswordFieldOptions {
                 max_length: Some(10),
+                min_length: Some(5),
+                size: Some(15),
+                autocomplete: Some(AutoComplete::Value("foo bar".to_string())),
+                placeholder: Some("Enter password".to_string()),
+                readonly: Some(false),
             },
         );
         let html = field.to_string();
         assert!(html.contains("type=\"password\""));
         assert!(html.contains("required"));
         assert!(html.contains("maxlength=\"10\""));
+        assert!(html.contains("minlength=\"5\""));
+        assert!(html.contains("autocomplete=\"foo bar\""));
+        assert!(html.contains("placeholder=\"Enter password\""));
     }
+
     #[cot::test]
     async fn password_field_clean_value() {
         let mut field = PasswordField::with_options(
@@ -904,6 +1211,7 @@ mod tests {
             },
             PasswordFieldOptions {
                 max_length: Some(10),
+                ..Default::default()
             },
         );
         field
@@ -923,18 +1231,33 @@ mod tests {
                 required: true,
             },
             EmailFieldOptions {
-                min_length: Some(10),
-                max_length: Some(50),
+                max_length: Some(10),
+                min_length: Some(5),
+                size: Some(15),
+                autocomplete: Some(AutoComplete::Value("foo bar".to_string())),
+                dir: Some(Dir::Ltr),
+                dirname: Some("dir".to_string()),
+                list: Some(List::new(["foo@example.com", "baz@example.com"])),
+                placeholder: Some("Enter text".to_string()),
+                readonly: Some(true),
             },
         );
 
         let html = field.to_string();
+
         assert!(html.contains("type=\"email\""));
         assert!(html.contains("required"));
-        assert!(html.contains("minlength=\"10\""));
-        assert!(html.contains("maxlength=\"50\""));
+        assert!(html.contains("minlength=\"5\""));
+        assert!(html.contains("maxlength=\"10\""));
         assert!(html.contains("name=\"test_id\""));
         assert!(html.contains("id=\"test_id\""));
+        assert!(html.contains("placeholder=\"Enter text\""));
+        assert!(html.contains("readonly"));
+        assert!(html.contains("autocomplete=\"foo bar\""));
+        assert!(html.contains("dir=\"ltr\""));
+        assert!(html.contains("dirname=\"dir\""));
+        assert!(html.contains("list=\"__test_id_datalist\""));
+        assert!(html.contains(r#"<datalist id="__test_id_datalist"><option value="foo@example.com">foo@example.com</option><option value="baz@example.com">baz@example.com</option></datalist>"#));
     }
 
     #[cot::test]
@@ -948,6 +1271,7 @@ mod tests {
             EmailFieldOptions {
                 min_length: Some(10),
                 max_length: Some(50),
+                ..Default::default()
             },
         );
 
@@ -971,6 +1295,7 @@ mod tests {
             EmailFieldOptions {
                 min_length: Some(10),
                 max_length: Some(50),
+                ..Default::default()
             },
         );
 
@@ -994,6 +1319,7 @@ mod tests {
             EmailFieldOptions {
                 min_length: Some(5),
                 max_length: Some(10),
+                ..Default::default()
             },
         );
 
@@ -1020,6 +1346,7 @@ mod tests {
             EmailFieldOptions {
                 min_length: Some(5),
                 max_length: Some(10),
+                ..Default::default()
             },
         );
 
@@ -1046,6 +1373,7 @@ mod tests {
             EmailFieldOptions {
                 min_length: Some(50),
                 max_length: Some(10),
+                ..Default::default()
             },
         );
 
@@ -1073,13 +1401,22 @@ mod tests {
             IntegerFieldOptions {
                 min: Some(1),
                 max: Some(10),
+                placeholder: Some("Enter text".to_string()),
+                readonly: Some(false),
+                step: Some(Step::Value(10)),
             },
         );
         let html = field.to_string();
+
         assert!(html.contains("type=\"number\""));
         assert!(html.contains("required"));
         assert!(html.contains("min=\"1\""));
         assert!(html.contains("max=\"10\""));
+        assert!(html.contains("step=\"10\""));
+        assert!(html.contains("placeholder=\"Enter text\""));
+        assert!(html.contains("name=\"test\""));
+        assert!(html.contains("id=\"test\""));
+        assert!(!html.contains("readonly"));
     }
 
     #[cot::test]
@@ -1093,6 +1430,7 @@ mod tests {
             IntegerFieldOptions {
                 min: Some(1),
                 max: Some(10),
+                ..Default::default()
             },
         );
         field
@@ -1114,6 +1452,7 @@ mod tests {
             IntegerFieldOptions {
                 min: Some(10),
                 max: Some(50),
+                ..Default::default()
             },
         );
         field
@@ -1138,6 +1477,7 @@ mod tests {
             IntegerFieldOptions {
                 min: Some(10),
                 max: Some(50),
+                ..Default::default()
             },
         );
         field
@@ -1218,13 +1558,22 @@ mod tests {
             FloatFieldOptions {
                 min: Some(1.5),
                 max: Some(10.7),
+                placeholder: Some("Enter text".to_string()),
+                readonly: Some(true),
+                step: Some(Step::Any),
             },
         );
         let html = field.to_string();
+
         assert!(html.contains("type=\"number\""));
         assert!(html.contains("required"));
         assert!(html.contains("min=\"1.5\""));
         assert!(html.contains("max=\"10.7\""));
+        assert!(html.contains("step=\"any\""));
+        assert!(html.contains("placeholder=\"Enter text\""));
+        assert!(html.contains("name=\"test\""));
+        assert!(html.contains("id=\"test\""));
+        assert!(html.contains("readonly"));
     }
 
     #[cot::test]
@@ -1239,6 +1588,7 @@ mod tests {
             FloatFieldOptions {
                 min: Some(1.0),
                 max: Some(10.0),
+                ..Default::default()
             },
         );
         field
@@ -1260,6 +1610,7 @@ mod tests {
             FloatFieldOptions {
                 min: Some(5.0),
                 max: Some(10.0),
+                ..Default::default()
             },
         );
         field
@@ -1284,6 +1635,7 @@ mod tests {
             FloatFieldOptions {
                 min: Some(5.0),
                 max: Some(10.0),
+                ..Default::default()
             },
         );
         field
@@ -1308,6 +1660,7 @@ mod tests {
             FloatFieldOptions {
                 min: Some(1.0),
                 max: Some(10.0),
+                ..Default::default()
             },
         );
         let bad_inputs = ["NaN", "inf"];
@@ -1338,6 +1691,7 @@ mod tests {
             FloatFieldOptions {
                 min: Some(1.0),
                 max: Some(10.0),
+                ..Default::default()
             },
         );
         field.set_value(FormFieldValue::new_text("")).await.unwrap();
@@ -1353,12 +1707,24 @@ mod tests {
                 name: "test".to_owned(),
                 required: true,
             },
-            UrlFieldOptions,
+            UrlFieldOptions {
+                max_length: Some(100),
+                min_length: Some(5),
+                size: Some(30),
+                list: Some(List::new(["https://example.com"])),
+                dir: Some(Dir::Ltr),
+                dirname: Some("dir".to_owned()),
+                autocomplete: Some(AutoComplete::Value("url".to_owned())),
+                placeholder: Some("Enter URL".to_owned()),
+                readonly: Some(true),
+            },
         );
+
         field
             .set_value(FormFieldValue::new_text("https://example.com"))
             .await
             .unwrap();
+
         let value = Url::clean_value(&field).unwrap();
         assert_eq!(
             value.as_str(),
@@ -1374,16 +1740,40 @@ mod tests {
                 name: "url".to_owned(),
                 required: true,
             },
-            UrlFieldOptions,
+            UrlFieldOptions {
+                max_length: Some(120),
+                min_length: Some(10),
+                size: Some(40),
+                list: Some(List::new(["https://one.com", "https://two.com"])),
+                dir: Some(Dir::Ltr),
+                dirname: Some("lang".to_owned()),
+                autocomplete: Some(AutoComplete::Value("url".to_owned())),
+                placeholder: Some("Paste link".to_owned()),
+                readonly: Some(true),
+            },
         );
+
         field
             .set_value(FormFieldValue::new_text("http://example.com"))
             .await
             .unwrap();
+
         let html = field.to_string();
+
         assert!(html.contains("type=\"url\""));
+        assert!(html.contains("id=\"id_url\""));
+        assert!(html.contains("name=\"id_url\""));
         assert!(html.contains("required"));
         assert!(html.contains("value=\"http://example.com\""));
+        assert!(html.contains("maxlength=\"120\""));
+        assert!(html.contains("minlength=\"10\""));
+        assert!(html.contains("size=\"40\""));
+        assert!(html.contains("placeholder=\"Paste link\""));
+        assert!(html.contains("autocomplete=\"url\""));
+        assert!(html.contains("dir=\"ltr\""));
+        assert!(html.contains("dirname=\"lang\""));
+        assert!(html.contains("readonly"));
+        assert!(html.contains("<datalist"));
     }
 
     #[cot::test]
@@ -1394,9 +1784,21 @@ mod tests {
                 name: "url".to_owned(),
                 required: true,
             },
-            UrlFieldOptions,
+            UrlFieldOptions {
+                max_length: Some(50),
+                min_length: Some(5),
+                size: Some(20),
+                list: None,
+                dir: Some(Dir::Rtl),
+                dirname: Some("rtl".to_owned()),
+                autocomplete: Some(AutoComplete::Off),
+                placeholder: Some("Enter a link".to_owned()),
+                readonly: Some(false),
+            },
         );
+
         field.set_value(FormFieldValue::new_text("")).await.unwrap();
+
         let value = Url::clean_value(&field);
         assert_eq!(value, Err(FormFieldValidationError::Required));
     }
diff --git a/cot/src/form/fields/attrs.rs b/cot/src/form/fields/attrs.rs
index 0b283d05..ac0962dd 100644
--- a/cot/src/form/fields/attrs.rs
+++ b/cot/src/form/fields/attrs.rs
@@ -1,8 +1,10 @@
 use std::fmt::{Display, Formatter};
 
-/// Represents the HTML `step` attribute for `<input>` elements:
+/// Represents the HTML [`step`] attribute for `<input>` elements:
 /// - `Any` → `step="any"`
 /// - `Value(T)` → `step="<value>"` where `T` is converted appropriately
+///
+/// [`step`]: https://developer.mozilla.org/en-US/docs/Web/HTML/Reference/Attributes/step
 #[derive(Debug, Copy, Clone)]
 pub enum Step<T> {
     /// Indicates that the user may enter any value (no fixed “step” interval).
@@ -26,3 +28,233 @@ impl<T: Display> Display for Step<T> {
         }
     }
 }
+
+/// Represents the HTML [`list`] attribute for `<input>` elements.
+/// Used to provide a set of predefined options for the input.
+///
+/// [`list`]: https://developer.mozilla.org/en-US/docs/Web/HTML/Element/input#list
+#[derive(Debug, Clone, Default)]
+pub struct List(Vec<String>);
+
+impl List {
+    /// Creates a new `List` from any iterator of string-like items.
+    ///
+    /// # Examples
+    /// ```
+    /// use cot::form::fields::List;
+    /// let list = List::new(vec!["Option 1", "Option 2", "Option 3"]);
+    /// ```
+    pub fn new<I, S>(iter: I) -> Self
+    where
+        I: IntoIterator<Item = S>,
+        S: AsRef<str>,
+    {
+        let v = iter.into_iter().map(|s| s.as_ref().to_string()).collect();
+        Self(v)
+    }
+
+    /// Returns an iterator over the items in the list.
+    ///
+    /// # Examples
+    /// ```
+    /// use cot::form::fields::List;
+    /// let list = List::new(vec!["Option 1", "Option 2", "Option 3"]);
+    /// for item in list.iter() {
+    ///     println!("{item:?}");
+    /// }
+    /// ```
+    pub fn iter(&self) -> std::slice::Iter<'_, String> {
+        self.0.iter()
+    }
+}
+
+impl IntoIterator for List {
+    type Item = String;
+    type IntoIter = std::vec::IntoIter<String>;
+
+    fn into_iter(self) -> Self::IntoIter {
+        self.0.into_iter()
+    }
+}
+
+impl<'a> IntoIterator for &'a List {
+    type Item = &'a String;
+    type IntoIter = std::slice::Iter<'a, String>;
+
+    fn into_iter(self) -> Self::IntoIter {
+        self.0.iter()
+    }
+}
+
+/// Represents the HTML [`autocomplete`] attribute for form fields.
+///
+/// [`autocomplete`]: https://developer.mozilla.org/en-US/docs/Web/HTML/Reference/Attributes/autocomplete
+#[derive(Debug, Clone)]
+pub enum AutoComplete {
+    /// Enables autocomplete.
+    On,
+    /// Disables autocomplete.
+    Off,
+    /// Custom autocomplete value.
+    Value(String),
+}
+
+impl AutoComplete {
+    /// Returns the string representation for use in HTML.
+    #[must_use]
+    pub fn as_str(&self) -> &str {
+        match self {
+            Self::Off => "off",
+            Self::On => "on",
+            Self::Value(value) => value.as_str(),
+        }
+    }
+}
+
+impl Display for AutoComplete {
+    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+        f.write_str(self.as_str())
+    }
+}
+
+/// Represents the HTML [`autocapitalize`] attribute for form fields.
+///
+/// [`autocapitalize`]: https://developer.mozilla.org/en-US/docs/Web/HTML/Reference/Global_attributes/autocapitalize
+#[derive(Debug, Clone, Copy)]
+pub enum AutoCapitalize {
+    /// No capitalization.
+    Off,
+    /// Capitalize all letters.
+    On,
+    /// Capitalize the first letter of each word.
+    Words,
+    /// Capitalize all characters.
+    Characters,
+}
+
+impl AutoCapitalize {
+    /// Returns the string representation for use in HTML.
+    fn as_str(self) -> &'static str {
+        match self {
+            AutoCapitalize::Off => "off",
+            AutoCapitalize::On => "on",
+            AutoCapitalize::Words => "words",
+            AutoCapitalize::Characters => "characters",
+        }
+    }
+}
+
+impl Display for AutoCapitalize {
+    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+        f.write_str(self.as_str())
+    }
+}
+
+/// Represents the HTML [`dir`] attribute for text direction.
+///
+/// [`dir`]: https://developer.mozilla.org/en-US/docs/Web/HTML/Reference/Global_attributes/dir
+#[derive(Debug, Clone, Copy)]
+pub enum Dir {
+    /// Right-to-left text direction.
+    Rtl,
+    /// Left-to-right text direction.
+    Ltr,
+    /// User agent auto-detects the text direction.
+    Auto,
+}
+
+impl Dir {
+    /// Returns the string representation for use in HTML.
+    #[must_use]
+    pub fn as_str(self) -> &'static str {
+        match self {
+            Self::Rtl => "rtl",
+            Self::Ltr => "ltr",
+            Self::Auto => "auto",
+        }
+    }
+}
+
+impl Display for Dir {
+    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+        f.write_str(self.as_str())
+    }
+}
+
+/// Represents the HTML [`capture`] attribute for file inputs.
+/// Used to specify the preferred source for file capture.
+///
+/// [`capture`]: https://developer.mozilla.org/en-US/docs/Web/HTML/Reference/Elements/input/file#capture
+#[derive(Debug, Clone, Copy)]
+pub enum Capture {
+    /// Use the user-facing camera or microphone.
+    User,
+    /// Use the environment-facing camera or microphone.
+    Environment,
+}
+
+impl Capture {
+    /// Returns the string representation for use in HTML.
+    pub fn as_str(self) -> &'static str {
+        match self {
+            Self::User => "user",
+            Self::Environment => "environment",
+        }
+    }
+}
+
+impl Display for Capture {
+    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+        f.write_str(self.as_str())
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn autocapitalize_as_str() {
+        assert_eq!(AutoCapitalize::Off.as_str(), "off");
+        assert_eq!(AutoCapitalize::On.as_str(), "on");
+        assert_eq!(AutoCapitalize::Words.as_str(), "words");
+        assert_eq!(AutoCapitalize::Characters.as_str(), "characters");
+    }
+
+    #[test]
+    fn autocapitalize_to_string() {
+        assert_eq!(AutoCapitalize::Off.to_string(), "off");
+        assert_eq!(AutoCapitalize::On.to_string(), "on");
+        assert_eq!(AutoCapitalize::Words.to_string(), "words");
+        assert_eq!(AutoCapitalize::Characters.to_string(), "characters");
+    }
+
+    #[test]
+    fn autocomplete_as_str() {
+        assert_eq!(AutoComplete::Off.as_str(), "off");
+        assert_eq!(AutoComplete::On.as_str(), "on");
+        let custom = AutoComplete::Value("email".to_string());
+        assert_eq!(custom.as_str(), "email");
+    }
+
+    #[test]
+    fn dir_as_str() {
+        assert_eq!(Dir::Rtl.as_str(), "rtl");
+        assert_eq!(Dir::Ltr.as_str(), "ltr");
+        assert_eq!(Dir::Auto.as_str(), "auto");
+    }
+
+    #[test]
+    fn dir_to_string() {
+        assert_eq!(Dir::Rtl.to_string(), "rtl");
+        assert_eq!(Dir::Ltr.to_string(), "ltr");
+        assert_eq!(Dir::Auto.to_string(), "auto");
+    }
+
+    #[test]
+    fn list_iter() {
+        let list = List::new(["Option 1", "Option 2", "Option 3"]);
+        let collected: Vec<&str> = list.iter().map(String::as_str).collect();
+        assert_eq!(collected, vec!["Option 1", "Option 2", "Option 3"]);
+    }
+}
diff --git a/cot/src/form/fields/files.rs b/cot/src/form/fields/files.rs
index fb107280..131080c4 100644
--- a/cot/src/form/fields/files.rs
+++ b/cot/src/form/fields/files.rs
@@ -5,6 +5,7 @@ use bytes::Bytes;
 use cot::form::{AsFormField, FormFieldValidationError};
 use cot::html::HtmlTag;
 
+use crate::form::fields::attrs::Capture;
 use crate::form::{FormField, FormFieldOptions, FormFieldValue, FormFieldValueError};
 
 #[derive(Debug)]
@@ -64,6 +65,8 @@ pub struct FileFieldOptions {
     ///
     /// [`accept` attribute]: https://developer.mozilla.org/en-US/docs/Web/HTML/Reference/Elements/input/file#limiting_accepted_file_types
     pub accept: Option<Vec<String>>,
+    /// The [`Capture`] attribute specifies the source of the file input.
+    pub capture: Option<Capture>,
 }
 
 impl Display for FileField {
@@ -78,6 +81,10 @@ impl Display for FileField {
             tag.attr("accept", accept.join(","));
         }
 
+        if let Some(capture) = self.custom_options.capture {
+            tag.attr("capture", capture.to_string());
+        }
+
         write!(f, "{}", tag.render())
     }
 }
@@ -161,6 +168,7 @@ mod tests {
             },
             FileFieldOptions {
                 accept: Some(vec!["image/*".to_string(), ".pdf".to_string()]),
+                capture: Some(Capture::Environment),
             },
         );
 
@@ -169,6 +177,7 @@ mod tests {
         assert!(html.contains("type=\"file\""));
         assert!(html.contains("required"));
         assert!(html.contains("accept=\"image/*,.pdf\""));
+        assert!(html.contains("capture=\"environment\""));
     }
 
     #[test]
@@ -179,7 +188,10 @@ mod tests {
                 name: "test".to_owned(),
                 required: true,
             },
-            FileFieldOptions { accept: None },
+            FileFieldOptions {
+                accept: None,
+                capture: Some(Capture::User),
+            },
         );
 
         let html = field.to_string();
@@ -187,6 +199,7 @@ mod tests {
         assert!(html.contains("type=\"file\""));
         assert!(html.contains("required"));
         assert!(!html.contains("accept="));
+        assert!(html.contains("capture=\"user\""));
     }
 
     #[cot::test]
@@ -197,7 +210,9 @@ mod tests {
                 name: "test".to_owned(),
                 required: true,
             },
-            FileFieldOptions { accept: None },
+            FileFieldOptions {
+                ..Default::default()
+            },
         );
 
         let boundary = "boundary";
@@ -232,7 +247,9 @@ mod tests {
                 name: "test".to_owned(),
                 required: true,
             },
-            FileFieldOptions { accept: None },
+            FileFieldOptions {
+                ..Default::default()
+            },
         );
 
         let value = InMemoryUploadedFile::clean_value(&field);