How to Escape Curly Braces in Rust Format Strings

By the end of this page, you will understand how Rust format strings treat curly braces, how to print literal { and } characters, and why backslashes are not the correct solution. You will also see practical examples using write!, format!, and println!.

In Rust, formatting macros such as println!, format!, and write! use curly braces as placeholders.

For example:

println!("Hello, {}", name);

Here, {} tells Rust where to insert a value.

Because braces are part of the formatting syntax, Rust does not treat them like normal characters inside a format string. If you want to print a literal brace, you must escape it using doubled braces, not backslashes.

• Use {{ to print {
• Use }} to print }

So this:

write!(f, "{{ hash:{}, subject: {} }}", self.hash, self.subject)

produces output like:

{ hash:123, subject: Rust }

Why this matters

Formatting is used everywhere in Rust:

Think of a Rust format string as a template with special slots.

• {} means: “put a value here”
• {{ means: “I really want an actual { character”
• }} means: “I really want an actual } character”

It is similar to quoting a special character in a mini-language. In Rust formatting, braces belong to the formatter itself, so you must tell Rust when a brace is part of the output instead of part of the formatting instruction.

The key rule is simple:

"{{" // prints {
"}}" // prints }

Basic example

fn main() {
    let hash = 42;
    let subject = "Rust";

    println!("{{ hash:{}, subject: {} }}", hash, subject);
}

Output:

{ hash:42, subject: Rust }

Using format!

fn main() {
    let name = "Alice";
    let message = format!("User record: {{ name: {} }}", name);
    println!("{}", message);
}

Using write! in a Display implementation

Consider this example:

fn main() {
    let hash = 7;
    let subject = "math";

    let text = format!("{{ hash:{}, subject: {} }}", hash, subject);
    println!("{}", text);
}

Step by step

1. Rust sees the format string:

   "{{ hash:{}, subject: {} }}"
   

2. The formatter reads {{ and turns it into a literal {.

3. It then reads the first {} and inserts hash, which is 7.

4. It continues through the text , subject: .

5. It reads the second {} and inserts subject, which is .

Literal braces appear often in real Rust programs.

1. Custom Display output

When implementing Display for a struct, you may want object-like output:

write!(f, "{{ id:{}, name:{} }}", self.id, self.name)

2. Logging structured-looking messages

println!("event={{ type:{}, status:{} }}", event_type, status);

3. Generating JSON-like text for debugging

This is not real JSON serialization, but sometimes useful for quick debug output:

println!("{{ \"ok\": {}, \"count\": {} }}", ok, count);

4. Building configuration snippets

let line = format!("section {{ key = {} }}", value);

5. Template-style output

If your output language uses braces, such as config formats or DSLs, doubled braces are common in format strings.

In real projects, developers often combine escaped braces with common formatting patterns.

Guarded formatting

Only include a section when data exists:

if let Some(tag) = &self.tag {
    write!(f, "{{ id:{}, tag:{} }}", self.id, tag)
} else {
    write!(f, "{{ id:{} }}", self.id)
}

Error messages with structure

eprintln!("Parse error {{ line:{}, column:{} }}", line, column);

Debug-style manual formatting

Sometimes developers want a custom output format instead of using #[derive(Debug)].

write!(f, "User {{ id:{}, active:{} }}", self.id, self.active)

Prefer serializers when output must be strict

If you need actual JSON, developers usually use serde_json instead of manually formatting braces and quotes.

Here are the most common mistakes beginners make.

Mistake 1: Using single braces literally

Broken code:

println!("{ name: {} }", "Alice");

Why it fails:

• Rust thinks { name: {} } is formatting syntax, not plain text.

Fix:

println!("{{ name: {} }}", "Alice");

Mistake 2: Using backslashes to escape braces

Broken code:

println!("\{ name: {} \}", "Alice");

Why it fails:

• Backslashes escape characters in Rust strings, not formatting placeholders.
• The formatting system still sees { and } as special.

Fix:

println!("{{ name: {} }}", "Alice");

Mistake 3: Forgetting that , , and all use the same rule

// Literal braces in Rust format strings
"{{"   // prints {
"}}"   // prints }

// Normal placeholder
"{}"   // inserts a value

Correct pattern

write!(f, "{{ hash:{}, subject: {} }}", self.hash, self.subject)

Rules

• {} inserts a value
• {{ prints {
• }} prints }
• Backslashes do not escape formatting braces
• The same rule applies to:
  • println!
  • print!
  • format!
  • write!
  • writeln!

Quick examples

How do I print a literal { in Rust?

Use {{ inside a format string.

How do I print a literal } in Rust?

Use }} inside a format string.

Why does \{ not work in println! or write!?

Because backslashes escape Rust string characters, not formatting placeholders. Format braces must be escaped with doubled braces.

Does this rule only apply to println!?

No. It also applies to format!, write!, writeln!, and related formatting macros.

What is the correct version of my original code?

write!(f, "{{ hash:{}, subject: {} }}", self.hash, self.subject)

Should I manually format JSON with braces like this?

Only for simple debug-like output. For real JSON, use a serializer such as serde_json.

• println! macro — uses the same format string rules.
• format! macro — builds strings using placeholders and escaped braces.
• write! macro — writes formatted text into buffers and formatters.
• Display trait — often implemented with write! for custom output.
• Debug trait — alternative way to print structs and values.
• String literals in Rust — useful for understanding what backslashes actually escape.
• Format specifiers — related because braces also contain formatting options like {:?} or {:#?}.