diff --git a/Cargo.toml b/Cargo.toml
index 891d662..91dcb5f 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -9,11 +9,11 @@ keywords = ["fortran", "formatter", "linter", "code-quality"]
 categories = ["development-tools", "command-line-utilities"]
 
 [dependencies]
-regex = "1"
 clap = { version = "4", features = ["derive"] }
 rayon = "1"
 ignore = "0.4"
 toml = "0.8"
 serde = { version = "1", features = ["derive"] }
 serde_json = "1"
+lazy-regex = "3.3.0"
 
diff --git a/src/classifier.rs b/src/classifier.rs
index 61fa816..299946f 100644
--- a/src/classifier.rs
+++ b/src/classifier.rs
@@ -1,5 +1,4 @@
-use regex::Regex;
-use std::sync::OnceLock;
+use lazy_regex::{regex, regex_is_match};
 
 /// Classification of a logical line.
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
@@ -22,22 +21,11 @@ pub enum LineKind {
     Blank,
 }
 
-/// Helper to get or compile a case-insensitive regex, cached in a OnceLock.
-macro_rules! re {
-    ($lock:ident, $pat:expr) => {{
-        static $lock: OnceLock<Regex> = OnceLock::new();
-        $lock.get_or_init(|| Regex::new($pat).unwrap())
-    }};
-}
-
 /// Classify a Fypp line (starts with `#:` or `#!`).
 fn classify_fypp(trimmed: &str) -> LineKind {
-    let re_block_open = re!(FYPP_OPEN, r"(?i)^#:\s*(if|for|def|call|block|mute)\b");
-    let re_block_close = re!(
-        FYPP_CLOSE,
-        r"(?i)^#:\s*(endif|endfor|enddef|endcall|endblock|endmute)\b"
-    );
-    let re_continuation = re!(FYPP_CONT, r"(?i)^#:\s*(elif|else)\b");
+    let re_block_open = regex!(r"(?i)^#:\s*(if|for|def|call|block|mute)\b");
+    let re_block_close = regex!(r"(?i)^#:\s*(endif|endfor|enddef|endcall|endblock|endmute)\b");
+    let re_continuation = regex!(r"(?i)^#:\s*(elif|else)\b");
 
     if re_block_close.is_match(trimmed) {
         LineKind::FyppBlockClose
@@ -53,10 +41,10 @@ fn classify_fypp(trimmed: &str) -> LineKind {
 
 /// Classify a preprocessor line (starts with `#` but not `#:` or `#!`).
 fn classify_preprocessor(trimmed: &str) -> LineKind {
-    let re_close = re!(CPP_CLOSE, r"(?i)^#\s*endif\b");
-    let re_cont = re!(CPP_CONT, r"(?i)^#\s*else\b");
+    let re_close = regex!(r"(?i)^#\s*endif\b");
+    let re_cont = regex!(r"(?i)^#\s*else\b");
     // Note: #else comes before this, so we won't match #elif as #else
-    let re_elif = re!(CPP_ELIF, r"(?i)^#\s*elif\b");
+    let re_elif = regex!(r"(?i)^#\s*elif\b");
 
     if re_close.is_match(trimmed) {
         LineKind::PreprocessorClose
@@ -145,7 +133,7 @@ fn classify_fortran(trimmed: &str) -> LineKind {
     // so the underlying statement is classified. The label is kept in the output;
     // stripping happens for classification only.
     let (trimmed, had_numeric_label) = {
-        let re_num_label = re!(NUM_LABEL, r"^\d+\s+");
+        let re_num_label = regex!(r"^\d+\s+");
         if let Some(m) = re_num_label.find(trimmed) {
             (trimmed[m.end()..].trim_start(), true)
         } else {
@@ -155,7 +143,7 @@ fn classify_fortran(trimmed: &str) -> LineKind {
 
     // Strip optional label prefix like "outer: "
     let line = {
-        let re_label = re!(LABEL, r"(?i)^\w+\s*:\s*");
+        let re_label = regex!(r"(?i)^\w+\s*:\s*");
         // Only strip if it looks like a construct label (not a keyword: like "type:")
         // A label must start with a letter and be followed by ":"
         if let Some(m) = re_label.find(trimmed) {
@@ -220,8 +208,7 @@ fn classify_fortran(trimmed: &str) -> LineKind {
     let lower = line.to_ascii_lowercase();
 
     // --- Block closers (check first since "end" prefix is distinctive) ---
-    let re_end_block = re!(
-        END_BLOCK,
+    let re_end_block = regex!(
         r"(?i)^end\s*(if|do|select|subroutine|function|module|submodule|program|interface|type|block|associate|where|forall|enum|critical|team)\b"
     );
     if let Some(m) = re_end_block.find(line) {
@@ -232,7 +219,7 @@ fn classify_fortran(trimmed: &str) -> LineKind {
             // A numeric-labeled "end do" may terminate a non-block labeled DO
             // ("do 10 ... 10 end do"); since "do <label>" does not push an
             // indentation scope, don't pop one here.
-            let re_end_do = re!(END_DO_LABELED, r"(?i)^end\s*do\b");
+            let re_end_do = regex!(r"(?i)^end\s*do\b");
             if had_numeric_label && re_end_do.is_match(line) {
                 return LineKind::FortranStatement;
             }
@@ -240,29 +227,29 @@ fn classify_fortran(trimmed: &str) -> LineKind {
         }
     }
     // Bare "end" (possibly followed by comment)
-    let re_bare_end = re!(BARE_END, r"(?i)^end\s*(!.*)?$");
+    let re_bare_end = regex!(r"(?i)^end\s*(!.*)?$");
     if re_bare_end.is_match(line) {
         return LineKind::FortranBlockClose;
     }
 
     // --- Continuations ---
     // else if ... then
-    let re_else_if = re!(ELSE_IF, r"(?i)^else\s*if\b");
+    let re_else_if = regex!(r"(?i)^else\s*if\b");
     if re_else_if.is_match(line) {
         return LineKind::FortranContinuation;
     }
     // bare else or named "else <construct-name>" (possibly followed by comment)
-    let re_bare_else = re!(BARE_ELSE, r"(?i)^else\b(\s+\w+)?\s*(!.*)?$");
+    let re_bare_else = regex!(r"(?i)^else\b(\s+\w+)?\s*(!.*)?$");
     if re_bare_else.is_match(line) {
         return LineKind::FortranContinuation;
     }
     // case (...) or case default
-    let re_case = re!(CASE, r"(?i)^case\s*(\(|default\b)");
+    let re_case = regex!(r"(?i)^case\s*(\(|default\b)");
     if re_case.is_match(line) {
         return LineKind::FortranContinuation;
     }
     // type is (...) / class is (...) / class default
-    let re_type_is = re!(TYPE_IS, r"(?i)^(type|class)\s+is\s*\(");
+    let re_type_is = regex!(r"(?i)^(type|class)\s+is\s*\(");
     if re_type_is.is_match(line) {
         return LineKind::FortranContinuation;
     }
@@ -272,12 +259,12 @@ fn classify_fortran(trimmed: &str) -> LineKind {
         return LineKind::FortranContinuation;
     }
     // rank (...) or rank default
-    let re_rank = re!(RANK_CONT, r"(?i)^rank\s*(\(|default\b)");
+    let re_rank = regex!(r"(?i)^rank\s*(\(|default\b)");
     if re_rank.is_match(line) {
         return LineKind::FortranContinuation;
     }
     // elsewhere
-    let re_elsewhere = re!(ELSEWHERE, r"(?i)^elsewhere\b");
+    let re_elsewhere = regex!(r"(?i)^elsewhere\b");
     if re_elsewhere.is_match(line) {
         return LineKind::FortranContinuation;
     }
@@ -291,7 +278,7 @@ fn classify_fortran(trimmed: &str) -> LineKind {
 
     // if (...) then
     if lower.starts_with("if") {
-        let re_if = re!(IF_OPEN, r"(?i)^if\s*\(");
+        let re_if = regex!(r"(?i)^if\s*\(");
         if re_if.is_match(line) {
             // Find the matching closing paren, then check if "then" follows
             if let Some(paren_start) = line.find('(') {
@@ -304,7 +291,7 @@ fn classify_fortran(trimmed: &str) -> LineKind {
                     // Could end with "then" or "label then"
                     if after_lower == "then" || after_lower.ends_with("then") {
                         // Check that it truly ends with "then"
-                        let re_then = re!(THEN_END, r"(?i)\bthen\s*$");
+                        let re_then = regex!(r"(?i)\bthen\s*$");
                         if re_then.is_match(&after_no_comment) {
                             return LineKind::FortranBlockOpen;
                         }
@@ -318,28 +305,25 @@ fn classify_fortran(trimmed: &str) -> LineKind {
     // Non-block labeled DO ("do 10 i = 1, n") is terminated by the labeled
     // statement ("10 continue"), which is classified as a plain statement, so
     // it must NOT open an indentation scope.
-    let re_do_label = re!(DO_LABEL, r"(?i)^do\s+\d+\b");
+    let re_do_label = regex!(r"(?i)^do\s+\d+\b");
     if re_do_label.is_match(line) {
         return LineKind::FortranStatement;
     }
 
     // do / do concurrent
-    let re_do = re!(DO_OPEN, r"(?i)^do\b");
+    let re_do = regex!(r"(?i)^do\b");
     if re_do.is_match(line) {
         return LineKind::FortranBlockOpen;
     }
 
     // select case/type/rank
-    let re_select = re!(SELECT, r"(?i)^select\s*(case|type|rank)\b");
+    let re_select = regex!(r"(?i)^select\s*(case|type|rank)\b");
     if re_select.is_match(line) {
         return LineKind::FortranBlockOpen;
     }
 
     // subroutine
-    let re_sub = re!(
-        SUB,
-        r"(?i)^(((pure|elemental|impure|recursive|module)\s+)*)subroutine\b"
-    );
+    let re_sub = regex!(r"(?i)^(((pure|elemental|impure|recursive|module)\s+)*)subroutine\b");
     if re_sub.is_match(line) {
         // But "module procedure" is a statement, not an opener
         // subroutine is always an opener
@@ -348,8 +332,7 @@ fn classify_fortran(trimmed: &str) -> LineKind {
 
     // function (with optional prefixes; type-spec prefixes may carry a paren
     // group with one level of nesting, e.g. type(point(8)), integer(kind=8))
-    let re_func = re!(
-        FUNC,
+    let re_func = regex!(
         r"(?i)^((((pure|elemental|impure|recursive|module)|(integer|real|double\s+precision|complex|character|logical|type|class)(\s*\(([^()]|\([^()]*\))*\))?)\s+)*)function\b"
     );
     if re_func.is_match(line) {
@@ -358,30 +341,30 @@ fn classify_fortran(trimmed: &str) -> LineKind {
 
     // module (but not "module procedure")
     if lower.starts_with("module") {
-        let re_mod_proc = re!(MOD_PROC, r"(?i)^module\s+procedure\b");
+        let re_mod_proc = regex!(r"(?i)^module\s+procedure\b");
         if re_mod_proc.is_match(line) {
             return LineKind::FortranStatement;
         }
-        let re_module = re!(MODULE, r"(?i)^module\b");
+        let re_module = regex!(r"(?i)^module\b");
         if re_module.is_match(line) {
             return LineKind::FortranBlockOpen;
         }
     }
 
     // submodule
-    let re_submod = re!(SUBMOD, r"(?i)^submodule\b");
+    let re_submod = regex!(r"(?i)^submodule\b");
     if re_submod.is_match(line) {
         return LineKind::FortranBlockOpen;
     }
 
     // program
-    let re_prog = re!(PROG, r"(?i)^program\b");
+    let re_prog = regex!(r"(?i)^program\b");
     if re_prog.is_match(line) {
         return LineKind::FortranBlockOpen;
     }
 
     // interface
-    let re_iface = re!(IFACE, r"(?i)^(abstract\s+)?interface\b");
+    let re_iface = regex!(r"(?i)^(abstract\s+)?interface\b");
     if re_iface.is_match(line) {
         return LineKind::FortranBlockOpen;
     }
@@ -389,13 +372,13 @@ fn classify_fortran(trimmed: &str) -> LineKind {
     // type definition vs type usage
     if lower.starts_with("type") {
         // type(name) :: x  -> statement (type usage/declaration)
-        let re_type_usage = re!(TYPE_USAGE, r"(?i)^type\s*\(");
+        let re_type_usage = regex!(r"(?i)^type\s*\(");
         if re_type_usage.is_match(line) {
             return LineKind::FortranStatement;
         }
         // type is (...) was already handled in continuations above
         // type :: name, type::name, or type, attrs :: name -> definition (block open)
-        let re_type_def = re!(TYPE_DEF, r"(?i)^type\s*(::|,|\s)");
+        let re_type_def = regex!(r"(?i)^type\s*(::|,|\s)");
         if re_type_def.is_match(line) {
             return LineKind::FortranBlockOpen;
         }
@@ -407,7 +390,7 @@ fn classify_fortran(trimmed: &str) -> LineKind {
 
     // where block vs statement
     if lower.starts_with("where") {
-        let re_where = re!(WHERE, r"(?i)^where\s*\(");
+        let re_where = regex!(r"(?i)^where\s*\(");
         if re_where.is_match(line) {
             if let Some(paren_start) = line.find('(') {
                 if let Some(close) = find_matching_paren(line, paren_start) {
@@ -424,7 +407,7 @@ fn classify_fortran(trimmed: &str) -> LineKind {
 
     // forall block vs statement (same logic as where)
     if lower.starts_with("forall") {
-        let re_forall = re!(FORALL, r"(?i)^forall\s*\(");
+        let re_forall = regex!(r"(?i)^forall\s*\(");
         if re_forall.is_match(line) {
             if let Some(paren_start) = line.find('(') {
                 if let Some(close) = find_matching_paren(line, paren_start) {
@@ -440,7 +423,7 @@ fn classify_fortran(trimmed: &str) -> LineKind {
     }
 
     // block data [name] (legacy program unit; "end block data" is a closer)
-    let re_block_data = re!(BLOCK_DATA, r"(?i)^block\s*data(\s+\w+)?\s*$");
+    let re_block_data = regex!(r"(?i)^block\s*data(\s+\w+)?\s*$");
     if re_block_data.is_match(line) {
         return LineKind::FortranBlockOpen;
     }
@@ -451,27 +434,27 @@ fn classify_fortran(trimmed: &str) -> LineKind {
     }
 
     // associate
-    let re_assoc = re!(ASSOC, r"(?i)^associate\s*\(");
+    let re_assoc = regex!(r"(?i)^associate\s*\(");
     if re_assoc.is_match(line) {
         return LineKind::FortranBlockOpen;
     }
 
     // critical
     if lower == "critical" || lower.starts_with("critical") {
-        let re_crit = re!(CRIT, r"(?i)^critical\b");
+        let re_crit = regex!(r"(?i)^critical\b");
         if re_crit.is_match(line) {
             return LineKind::FortranBlockOpen;
         }
     }
 
     // enum
-    let re_enum = re!(ENUM, r"(?i)^enum\b");
+    let re_enum = regex!(r"(?i)^enum\b");
     if re_enum.is_match(line) {
         return LineKind::FortranBlockOpen;
     }
 
     // change team
-    let re_change_team = re!(CHANGE_TEAM, r"(?i)^change\s+team\b");
+    let re_change_team = regex!(r"(?i)^change\s+team\b");
     if re_change_team.is_match(line) {
         return LineKind::FortranBlockOpen;
     }
@@ -615,17 +598,14 @@ pub fn extract_scope_name(line: &str) -> Option<String> {
     let lower = trimmed.to_ascii_lowercase();
 
     // subroutine name(...) or subroutine name
-    let re_sub = re!(
-        SCOPE_SUB,
-        r"(?i)(?:(?:pure|elemental|impure|recursive|module)\s+)*subroutine\s+(\w+)"
-    );
+    let re_sub =
+        regex!(r"(?i)(?:(?:pure|elemental|impure|recursive|module)\s+)*subroutine\s+(\w+)");
     if let Some(caps) = re_sub.captures(trimmed) {
         return Some(caps[1].to_string());
     }
 
     // function name(...) or function name
-    let re_func = re!(
-        SCOPE_FUNC,
+    let re_func = regex!(
         r"(?i)(?:(?:pure|elemental|impure|recursive|module|(?:integer|real|double\s+precision|complex|character|logical|type|class)(?:\s*\((?:[^()]|\([^()]*\))*\))?)\s+)*function\s+(\w+)"
     );
     if let Some(caps) = re_func.captures(trimmed) {
@@ -634,7 +614,7 @@ pub fn extract_scope_name(line: &str) -> Option<String> {
 
     // module name (but not "module procedure")
     if lower.starts_with("module") {
-        let re_mod = re!(SCOPE_MOD, r"(?i)^module\s+(\w+)");
+        let re_mod = regex!(r"(?i)^module\s+(\w+)");
         if let Some(caps) = re_mod.captures(trimmed) {
             let name = &caps[1];
             if !name.eq_ignore_ascii_case("procedure") {
@@ -644,7 +624,7 @@ pub fn extract_scope_name(line: &str) -> Option<String> {
     }
 
     // program name
-    let re_prog = re!(SCOPE_PROG, r"(?i)^program\s+(\w+)");
+    let re_prog = regex!(r"(?i)^program\s+(\w+)");
     if let Some(caps) = re_prog.captures(trimmed) {
         return Some(caps[1].to_string());
     }
@@ -652,12 +632,12 @@ pub fn extract_scope_name(line: &str) -> Option<String> {
     // type [, attrs] :: name  or  type name
     if lower.starts_with("type") {
         // type :: name  or  type, extends(...) :: name
-        let re_type_def = re!(SCOPE_TYPE, r"(?i)^type\b[^(]*::\s*(\w+)");
+        let re_type_def = regex!(r"(?i)^type\b[^(]*::\s*(\w+)");
         if let Some(caps) = re_type_def.captures(trimmed) {
             return Some(caps[1].to_string());
         }
         // type name (no :: but also not type(...) which is usage)
-        let re_type_bare = re!(SCOPE_TYPE_BARE, r"(?i)^type\s+(\w+)\s*$");
+        let re_type_bare = regex!(r"(?i)^type\s+(\w+)\s*$");
         if let Some(caps) = re_type_bare.captures(trimmed) {
             let name = &caps[1];
             // Exclude "type is" which is a continuation
@@ -668,7 +648,7 @@ pub fn extract_scope_name(line: &str) -> Option<String> {
     }
 
     // submodule(parent) name
-    let re_submod = re!(SCOPE_SUBMOD, r"(?i)^submodule\s*\([^)]*\)\s*(\w+)");
+    let re_submod = regex!(r"(?i)^submodule\s*\([^)]*\)\s*(\w+)");
     if let Some(caps) = re_submod.captures(trimmed) {
         return Some(caps[1].to_string());
     }
@@ -680,11 +660,10 @@ pub fn extract_scope_name(line: &str) -> Option<String> {
 /// E.g., `end subroutine s_foo` -> true, `end subroutine` -> false.
 pub fn end_statement_has_name(line: &str) -> bool {
     let trimmed = line.trim();
-    let re_end_with_name = re!(
-        END_WITH_NAME,
-        r"(?i)^end\s+(subroutine|function|module|submodule|program|type)\s+\w+"
-    );
-    re_end_with_name.is_match(trimmed)
+    regex_is_match!(
+        r"(?i)^end\s+(subroutine|function|module|submodule|program|type)\s+\w+",
+        trimmed
+    )
 }
 
 /// Extract the block keyword from an `end` statement.
diff --git a/src/formatter.rs b/src/formatter.rs
index aaedab9..cee9038 100644
--- a/src/formatter.rs
+++ b/src/formatter.rs
@@ -1,3 +1,5 @@
+use lazy_regex::{regex, regex_is_match, regex_replace};
+
 use crate::case_norm::normalize_case;
 use crate::classifier::{
     classify, end_block_keyword, end_statement_has_name, extract_scope_name, LineKind,
@@ -47,18 +49,17 @@ fn apply_indent(line: &str, depth: usize, indent_width: usize) -> String {
 fn is_end_procedure(line: &str) -> bool {
     let trimmed = line.trim();
     let lower = trimmed.to_ascii_lowercase();
-    let re_end_proc = regex::Regex::new(r"(?i)^end\s+(subroutine|function)\b").unwrap();
-    re_end_proc.is_match(&lower)
+    regex_is_match!(r"(?i)^end\s+(subroutine|function)\b", &lower)
 }
 
 /// Check if a line starts a new procedure (subroutine or function).
 fn is_procedure_start(line: &str) -> bool {
     let trimmed = line.trim();
     let lower = trimmed.to_ascii_lowercase();
-    let re_proc = regex::Regex::new(
-        r"(?i)^(?:(?:pure|elemental|impure|recursive|module|integer|real|double\s+precision|complex|character|logical|type\s*\([^)]*\))\s+)*(subroutine|function)\b"
-    ).unwrap();
-    re_proc.is_match(&lower)
+    regex_is_match!(
+        r"(?i)^(?:(?:pure|elemental|impure|recursive|module|integer|real|double\s+precision|complex|character|logical|type\s*\([^)]*\))\s+)*(subroutine|function)\b",
+        &lower
+    )
 }
 
 /// Format a Fortran source string using default config.
@@ -1489,11 +1490,10 @@ fn remove_blanks_before_closers(lines: &[String]) -> Vec<String> {
 /// These are logical unit boundaries that should be separated from following Doxygen comments.
 fn is_major_end_block(line: &str) -> bool {
     let trimmed = line.trim().to_ascii_lowercase();
-    let re = regex::Regex::new(
+    regex_is_match!(
         r"(?i)^end\s+(subroutine|function|module|submodule|program|type|interface)\b",
+        &trimmed
     )
-    .unwrap();
-    re.is_match(&trimmed)
 }
 
 /// Check if a line is `end subroutine` or `end function`.
@@ -1521,10 +1521,10 @@ fn is_module_or_program(line: &str) -> bool {
 /// Check if a line is a subroutine/function opener.
 fn is_procedure_opener(line: &str) -> bool {
     let lower = line.trim().to_ascii_lowercase();
-    let re = regex::Regex::new(
-        r"(?i)^(?:(?:pure|elemental|impure|recursive|module|integer|real|double\s+precision|complex|character|logical|type\s*\([^)]*\))\s+)*(subroutine|function)\b"
-    ).unwrap();
-    re.is_match(&lower)
+    regex_is_match!(
+        r"(?i)^(?:(?:pure|elemental|impure|recursive|module|integer|real|double\s+precision|complex|character|logical|type\s*\([^)]*\))\s+)*(subroutine|function)\b",
+        &lower
+    )
 }
 
 /// Ensure blank lines at structural boundaries:
@@ -1854,9 +1854,9 @@ fn separate_declarations_from_code(lines: &[String]) -> Vec<String> {
     // Track whether we're in a declaration region at the top of a procedure
     let mut in_decl_region = false;
     let mut saw_declaration = false;
-    let proc_re = regex::Regex::new(
+    let proc_re = regex!(
         r"(?i)^(?:(?:pure|elemental|impure|recursive|module|integer|real|double\s+precision|complex|character|logical|type\s*\([^)]*\))\s+)*(subroutine|function)\b"
-    ).unwrap();
+    );
 
     for line in lines {
         let trimmed = line.trim();
@@ -2467,11 +2467,7 @@ fn find_token_breaks(content: &str) -> Vec<(usize, BreakKind)> {
 /// Remove space between Fypp macro name and ( on $: and @: lines.
 /// E.g., "$:GPU_PARALLEL_LOOP (collapse=3)" -> "$:GPU_PARALLEL_LOOP(collapse=3)"
 fn remove_fypp_macro_paren_space(line: &str) -> String {
-    use regex::Regex;
-    use std::sync::OnceLock;
-    static RE: OnceLock<Regex> = OnceLock::new();
-    let re = RE.get_or_init(|| Regex::new(r"(?m)^(\s*[@$]:[\w]+)\s+\(").unwrap());
-    re.replace(line, r"${1}(").to_string()
+    regex_replace!(r"(?m)^(\s*[@$]:[\w]+)\s+\(", line, r"${1}(").to_string()
 }
 
 /// Normalize comma spacing inside Fypp '[...]' list arguments.
@@ -2613,28 +2609,22 @@ fn modernize_relational_operators(lines: &[String]) -> Vec<String> {
 /// Enforce `::` separator in variable declarations that are missing it.
 /// E.g., `integer x` -> `integer :: x`, `type(foo) bar` -> `type(foo) :: bar`.
 fn enforce_double_colon(lines: &[String]) -> Vec<String> {
-    use regex::Regex;
-    use std::sync::OnceLock;
-
     // Match simple type declarations without ::
     // Group 1: indent + type keyword (+ optional kind/attributes)
     // Group 2: variable name(s)
-    static RE_SIMPLE: OnceLock<Regex> = OnceLock::new();
-    let re_simple = RE_SIMPLE.get_or_init(|| {
-        Regex::new(r"(?i)^(\s*(?:integer|real|logical|complex|character|double\s+precision)(?:\s*\([^)]*\))?(?:\s*,\s*(?:intent\s*\([^)]*\)|dimension\s*\([^)]*\)|allocatable|pointer|target|optional|save|parameter|value|contiguous|external|intrinsic|volatile|asynchronous|protected|private|public))*)\s+([a-zA-Z_]\w*.*)$").unwrap()
-    });
+    let re_simple = regex!(
+        r"(?i)^(\s*(?:integer|real|logical|complex|character|double\s+precision)(?:\s*\([^)]*\))?(?:\s*,\s*(?:intent\s*\([^)]*\)|dimension\s*\([^)]*\)|allocatable|pointer|target|optional|save|parameter|value|contiguous|external|intrinsic|volatile|asynchronous|protected|private|public))*)\s+([a-zA-Z_]\w*.*)$"
+    );
 
     // Match type()/class() declarations without ::
-    static RE_TYPED: OnceLock<Regex> = OnceLock::new();
-    let re_typed = RE_TYPED.get_or_init(|| {
-        Regex::new(r"(?i)^(\s*(?:type|class)\s*\([^)]*\)(?:\s*,\s*(?:intent\s*\([^)]*\)|dimension\s*\([^)]*\)|allocatable|pointer|target|optional|save|parameter|value|contiguous|external|intrinsic|volatile|asynchronous|protected|private|public))*)\s+([a-zA-Z_]\w*.*)$").unwrap()
-    });
+    let re_typed = regex!(
+        r"(?i)^(\s*(?:type|class)\s*\([^)]*\)(?:\s*,\s*(?:intent\s*\([^)]*\)|dimension\s*\([^)]*\)|allocatable|pointer|target|optional|save|parameter|value|contiguous|external|intrinsic|volatile|asynchronous|protected|private|public))*)\s+([a-zA-Z_]\w*.*)$"
+    );
 
     // Non-declaration keywords that might look like declarations
-    static RE_SKIP: OnceLock<Regex> = OnceLock::new();
-    let re_skip = RE_SKIP.get_or_init(|| {
-        Regex::new(r"(?i)^\s*(?:if|do|else|end|call|return|write|read|print|open|close|format|go\s*to|select|case|where|forall|block|associate|critical|sync|lock|unlock|event|error|stop|exit|cycle|continue|contains|implicit|use|module|program|subroutine|function|interface|abstract|procedure|entry|include|equivalence|common|data|namelist|save|allocate|deallocate|nullify|inquire|rewind|backspace|endfile|flush|wait|type\s+is|class\s+is|class\s+default|rank\s+default|rank\s*\()\b").unwrap()
-    });
+    let re_skip = regex!(
+        r"(?i)^\s*(?:if|do|else|end|call|return|write|read|print|open|close|format|go\s*to|select|case|where|forall|block|associate|critical|sync|lock|unlock|event|error|stop|exit|cycle|continue|contains|implicit|use|module|program|subroutine|function|interface|abstract|procedure|entry|include|equivalence|common|data|namelist|save|allocate|deallocate|nullify|inquire|rewind|backspace|endfile|flush|wait|type\s+is|class\s+is|class\s+default|rank\s+default|rank\s*\()\b"
+    );
 
     lines
         .iter()
diff --git a/src/keyword_norm.rs b/src/keyword_norm.rs
index 7c2756a..069f8ff 100644
--- a/src/keyword_norm.rs
+++ b/src/keyword_norm.rs
@@ -1,3 +1,4 @@
+use lazy_regex::{regex, Lazy};
 use regex::Regex;
 use std::sync::OnceLock;
 
@@ -70,38 +71,34 @@ fn split_at_comment(line: &str) -> (&str, &str) {
 fn normalize_code_keywords(code: &str) -> String {
     // end* compounds — applied with a suffix check: `endif = 3` is an
     // assignment to a variable named endif, not a block close.
-    static END_RE: OnceLock<Regex> = OnceLock::new();
-    let end_re = END_RE.get_or_init(|| {
-        Regex::new(r"(?i)\b(end)(do|if|select|subroutine|function|module|submodule|program|interface|type|block|associate|where|forall|enum|critical|team)\b").unwrap()
-    });
-    static RE: OnceLock<Vec<(Regex, &str)>> = OnceLock::new();
+    let end_re = regex!(
+        r"(?i)\b(end)(do|if|select|subroutine|function|module|submodule|program|interface|type|block|associate|where|forall|enum|critical|team)\b"
+    );
+    static RE: OnceLock<Vec<(&Lazy<Regex>, &str)>> = OnceLock::new();
     let patterns = RE.get_or_init(|| {
         vec![
             // end* compounds — capture both parts to preserve case:
             // "ENDDO" → "END DO", "EndDo" → "End Do", "enddo" → "end do"
 
             // else if — normalize spacing (but NOT elsewhere, which is a single keyword)
-            (Regex::new(r"(?i)\b(else)\s*(if)\b").unwrap(), "$1 $2"),
-            (Regex::new(r"(?i)\b(select)\s*(case)\b").unwrap(), "$1 $2"),
-            (Regex::new(r"(?i)\b(select)\s*(type)\b").unwrap(), "$1 $2"),
-            (Regex::new(r"(?i)\b(select)\s*(rank)\b").unwrap(), "$1 $2"),
+            (regex!(r"(?i)\b(else)\s*(if)\b"), "$1 $2"),
+            (regex!(r"(?i)\b(select)\s*(case)\b"), "$1 $2"),
+            (regex!(r"(?i)\b(select)\s*(type)\b"), "$1 $2"),
+            (regex!(r"(?i)\b(select)\s*(rank)\b"), "$1 $2"),
             // double precision
-            (
-                Regex::new(r"(?i)\b(double)\s*(precision)\b").unwrap(),
-                "$1 $2",
-            ),
+            (regex!(r"(?i)\b(double)\s*(precision)\b"), "$1 $2"),
             // error stop, change team, go to
-            (Regex::new(r"(?i)\b(error)\s*(stop)\b").unwrap(), "$1 $2"),
-            (Regex::new(r"(?i)\b(change)\s*(team)\b").unwrap(), "$1 $2"),
-            (Regex::new(r"(?i)\b(go)\s*(to)\b").unwrap(), "$1 $2"),
+            (regex!(r"(?i)\b(error)\s*(stop)\b"), "$1 $2"),
+            (regex!(r"(?i)\b(change)\s*(team)\b"), "$1 $2"),
+            (regex!(r"(?i)\b(go)\s*(to)\b"), "$1 $2"),
             // coarray compounds
-            (Regex::new(r"(?i)\b(sync)\s*(all)\b").unwrap(), "$1 $2"),
-            (Regex::new(r"(?i)\b(sync)\s*(images)\b").unwrap(), "$1 $2"),
-            (Regex::new(r"(?i)\b(sync)\s*(memory)\b").unwrap(), "$1 $2"),
-            (Regex::new(r"(?i)\b(event)\s*(post)\b").unwrap(), "$1 $2"),
-            (Regex::new(r"(?i)\b(event)\s*(wait)\b").unwrap(), "$1 $2"),
-            (Regex::new(r"(?i)\b(fail)\s*(image)\b").unwrap(), "$1 $2"),
-            (Regex::new(r"(?i)\b(form)\s*(team)\b").unwrap(), "$1 $2"),
+            (regex!(r"(?i)\b(sync)\s*(all)\b"), "$1 $2"),
+            (regex!(r"(?i)\b(sync)\s*(images)\b"), "$1 $2"),
+            (regex!(r"(?i)\b(sync)\s*(memory)\b"), "$1 $2"),
+            (regex!(r"(?i)\b(event)\s*(post)\b"), "$1 $2"),
+            (regex!(r"(?i)\b(event)\s*(wait)\b"), "$1 $2"),
+            (regex!(r"(?i)\b(fail)\s*(image)\b"), "$1 $2"),
+            (regex!(r"(?i)\b(form)\s*(team)\b"), "$1 $2"),
         ]
     });
 
diff --git a/src/whitespace.rs b/src/whitespace.rs
index 6e46f6b..5d9767e 100644
--- a/src/whitespace.rs
+++ b/src/whitespace.rs
@@ -50,6 +50,8 @@ enum OpKind {
     Comment,
 }
 
+use lazy_regex::regex;
+
 use crate::config::WhitespaceConfig;
 
 /// Normalize whitespace in a Fortran line.
@@ -117,13 +119,9 @@ fn string_mask_and_comment_start(line: &str) -> (Vec<bool>, usize) {
 /// Add a space between control-flow keywords and `(` where missing.
 /// E.g., `if(x)` → `if (x)`, `call foo(` → `call foo(`  (call already has space)
 pub fn add_keyword_paren_spaces(line: &str) -> String {
-    use regex::Regex;
-    use std::sync::OnceLock;
-
-    static RE: OnceLock<Regex> = OnceLock::new();
-    let re = RE.get_or_init(|| {
-        Regex::new(r"(?i)\b(if|else\s*if|do\s+while|select\s+case|select\s+type|select\s+rank|where|forall|associate|call|write|read|open|close|inquire|allocate|deallocate|nullify)\(").unwrap()
-    });
+    let re = regex!(
+        r"(?i)\b(if|else\s*if|do\s+while|select\s+case|select\s+type|select\s+rank|where|forall|associate|call|write|read|open|close|inquire|allocate|deallocate|nullify)\("
+    );
 
     // Walk through matches and insert space before (
     // We need to be careful not to modify content inside strings or comments
@@ -237,11 +235,7 @@ fn normalize_comment_bang(comment: &str) -> String {
 /// Remove space between `intent` and `(` — convention is `intent(in)` not `intent (in)`.
 /// Leaves string literals and comments untouched.
 pub fn normalize_intent_paren(line: &str) -> String {
-    use regex::Regex;
-    use std::sync::OnceLock;
-
-    static RE: OnceLock<Regex> = OnceLock::new();
-    let re = RE.get_or_init(|| Regex::new(r"(?i)\bintent\s+\(").unwrap());
+    let re = regex!(r"(?i)\bintent\s+\(");
 
     let (string_mask, comment_start) = string_mask_and_comment_start(line);
     let mut result = String::with_capacity(line.len());