CSS code can become difficult to read and maintain when styles are written without proper indentation, spacing, or organization. This problem is common when working with large stylesheets, copying CSS snippets from different sources, or maintaining an existing website.
Formatting and beautifying CSS code means organizing its rules, selectors, properties, and declarations into a consistent, readable structure. Instead of writing an entire stylesheet on a few lines, you can arrange each selector and its properties separately, making the code easier to understand and edit.
The easiest way to format CSS is to use an automated formatter such as Prettier or the built-in formatting feature in Visual Studio Code. You can also use an online CSS beautifier when you need to quickly format a small code snippet.
This guide explains how to format CSS manually and automatically, how to use CSS formatting tools, and which practices help maintain clean stylesheets throughout a web development project.
What Does Formatting and Beautifying CSS Mean?
CSS formatting refers to organizing stylesheet code using consistent indentation, line breaks, spacing, and declaration placement.
CSS consists of rulesets containing selectors and declaration blocks. Each declaration generally includes a property and its corresponding value.
For example:
h1 {
color: #222222;
font-size: 32px;
font-weight: bold;
}
This example contains a selector (h1) and three declarations that control the appearance of heading elements.
When CSS is not properly formatted, the same code might appear like this:
h1{color:#222222;font-size:32px;font-weight:bold;}p{color:#555555;font-size:16px;line-height:1.6;}body{margin:0;padding:0;font-family:Arial,sans-serif;}
Although this is valid CSS, it is harder to read and edit.
A beautified version organizes each selector and its declarations into separate blocks:
body {
margin: 0;
padding: 0;
font-family: Arial, sans-serif;
}
h1 {
color: #222222;
font-size: 32px;
font-weight: bold;
}
p {
color: #555555;
font-size: 16px;
line-height: 1.6;
}
The formatting makes individual rules easier to identify without changing their intended styling.
Why Should You Format CSS Code?
Proper CSS formatting is useful for both small websites and large development projects.
1. Improves Code Readability
Readable CSS makes it easier to understand which styles apply to particular HTML elements.
Developers can quickly identify selectors, properties, and values without examining a long, compressed line of code.
2. Makes Debugging Easier
When a website displays an unexpected color, margin, font size, or layout, developers often need to inspect the relevant CSS rules.
Organized stylesheets make it easier to locate declarations and identify potential problems.
However, formatting alone does not correct incorrect CSS values, selector conflicts, or specificity problems.
3. Simplifies Website Maintenance
Websites regularly require visual updates.
You may need to change button colors, adjust responsive layouts, update typography, or modify spacing between sections.
Well-formatted CSS makes these updates easier because related declarations are organized into identifiable blocks.
4. Improves Team Collaboration
When multiple developers work on a website, inconsistent formatting can make code reviews difficult.
A shared formatting convention ensures that everyone follows the same indentation and spacing rules.
5. Helps Organize Large Stylesheets
As websites grow, their CSS files may contain hundreds of selectors and thousands of declarations.
Grouping related styles and maintaining a consistent structure helps prevent unnecessary confusion.
How to Format CSS Code Manually
You can manually beautify CSS by following a few basic formatting rules.
Step 1: Place Each CSS Selector on a Separate Line
Start by separating individual selectors into their own rulesets.
Avoid writing multiple unrelated selectors and declarations together without line breaks.
Poorly formatted CSS:
body{margin:0;padding:0;}h1{font-size:32px;color:#222;}p{font-size:16px;color:#555;}
Properly formatted CSS:
body {
margin: 0;
padding: 0;
}
h1 {
font-size: 32px;
color: #222;
}
p {
font-size: 16px;
color: #555;
}
This arrangement makes it easier to identify each selector and the styles associated with it.
Step 2: Use Consistent Indentation
Indent declarations inside their corresponding CSS rulesets.
For example:
.container {
width: 100%;
max-width: 1200px;
margin: 0 auto;
}
Here, each declaration is indented by four spaces.
Two spaces per indentation level is also widely used. The choice is a matter of project convention rather than a CSS requirement.
Choose one approach and apply it consistently.
Step 3: Add Spaces Around CSS Syntax
Use appropriate spaces around braces, colons, and certain operators to make declarations readable.
For example:
Incorrect formatting style:
.card{background:#fff;padding:20px;border:1px solid #ddd;}
Recommended formatting:
.card {
background: #fff;
padding: 20px;
border: 1px solid #ddd;
}
Notice the space between the selector and opening brace, and after each declaration’s colon.
Avoid adding arbitrary spaces inside values, strings, or other CSS expressions because some whitespace is significant to CSS parsing.
Step 4: Put Each Declaration on a Separate Line
Every declaration should generally appear on its own line.
Hard-to-read CSS:
button{background:blue;color:white;padding:12px 20px;border:none;border-radius:6px;cursor:pointer;}
Readable CSS:
button {
background: blue;
color: white;
padding: 12px 20px;
border: none;
border-radius: 6px;
cursor: pointer;
}
This makes it easier to update a particular property without accidentally modifying another declaration.
Step 5: Separate Different Rulesets With Blank Lines
Use blank lines to distinguish unrelated selectors.
For example:
header {
background: #222222;
padding: 20px;
}
nav {
display: flex;
gap: 20px;
}
footer {
background: #111111;
color: #ffffff;
padding: 30px;
}
Blank lines improve the visual separation between blocks and make larger stylesheets easier to scan.
Step 6: Organize Properties Logically
You can group related properties together instead of placing them randomly.
For example:
.product-card {
/* Layout */
display: flex;
flex-direction: column;
gap: 16px;
/* Dimensions */
width: 100%;
max-width: 350px;
/* Spacing */
padding: 20px;
margin: 10px;
/* Appearance */
background: #ffffff;
border: 1px solid #dddddd;
border-radius: 8px;
/* Typography */
color: #333333;
font-size: 16px;
}
Comments help distinguish different groups of properties.
This style of organization is particularly useful when working with complex components.
There is no mandatory universal property order in CSS. Choose a logical convention that works for the project.
Step 7: Format Media Queries Properly
Responsive CSS often contains several media queries. Formatting them consistently helps developers understand which styles apply at different screen sizes.
Poorly formatted CSS:
@media(max-width:768px){.container{padding:15px;}h1{font-size:26px;}nav{flex-direction:column;}}
Properly formatted CSS:
@media (max-width: 768px) {
.container {
padding: 15px;
}
h1 {
font-size: 26px;
}
nav {
flex-direction: column;
}
}
Media query conditions, selectors, and declaration blocks are now clearly separated.
Step 8: Organize CSS Comments
Use comments to explain complex styling decisions or separate major stylesheet sections.
CSS comments use the following syntax:
/* This is a CSS comment */
For a larger stylesheet, you might use:
/* =========================
Header Styles
========================= */
header {
background: #222222;
padding: 20px;
}
/* =========================
Main Content
========================= */
main {
max-width: 1200px;
margin: 0 auto;
}
/* =========================
Footer Styles
========================= */
footer {
background: #111111;
color: #ffffff;
padding: 30px;
}
Use comments where they add useful context. Avoid writing comments that merely repeat what an obvious declaration already explains.
How to Format and Beautify CSS Automatically Using Prettier
Manually formatting CSS works well for smaller stylesheets. However, an automated formatter is more practical when working with larger files.
Prettier is a code formatter that supports CSS, HTML, JavaScript, and several other languages.
It automatically organizes code according to configured formatting preferences.
Step 1: Install Visual Studio Code
Download and install Visual Studio Code if you do not already have a code editor.
Open your CSS file using the editor.
Step 2: Install the Prettier Extension
Open the Extensions panel in Visual Studio Code.
Search for Prettier – Code Formatter and install the extension.
It allows you to format CSS directly within the editor.
Step 3: Open Your CSS File
Select the CSS file you want to beautify.
For example:
website/
index.html
style.css
responsive.css
Open style.css in the editor.
Step 4: Run Format Document
In Visual Studio Code:
- Open your CSS file.
- Right-click inside the editor.
- Select Format Document.
- Select Prettier as the formatter if prompted.
- Review the formatted CSS.
You can also use the keyboard shortcut:
- Windows: Shift + Alt + F
- macOS: Shift + Option + F
VS Code also includes a built-in formatter for CSS, so an additional extension is not strictly necessary for basic formatting.
Step 5: Configure Prettier Formatting Preferences
You can customize CSS formatting through a .prettierrc configuration file in your project directory.
Example:
{
“tabWidth”: 2,
“useTabs”: false,
“printWidth”: 80,
“singleQuote”: false
}
Here is what the settings mean:
| Setting | Purpose |
| tabWidth | Controls indentation width |
| useTabs | Determines whether indentation uses tabs |
| printWidth | Sets the preferred line-wrapping width |
| singleQuote | Controls quotation style where supported |
The print width is a formatting preference, not a strict maximum line length.
Step 6: Format CSS Automatically When Saving
You can configure Visual Studio Code to format CSS whenever you save a file.
Open the editor settings and enable Format On Save.
You can also add the following to your project’s settings.json:
{
“editor.formatOnSave”: true,
“[css]”: {
“editor.defaultFormatter”: “esbenp.prettier-vscode”
}
}
This configuration uses Prettier as the default CSS formatter and automatically formats supported CSS files when saved.
Check that the extension is installed and enabled before using this setting.
How to Format CSS Using the Command Line
Developers working with larger projects can use Prettier directly from the terminal.
This is particularly useful when formatting multiple stylesheets or integrating formatting into a development workflow.
Step 1: Install Prettier
If your project already uses Node.js and npm, install Prettier as a development dependency:
npm install –save-dev prettier
Step 2: Format a Single CSS File
Run:
npx prettier style.css –write
This formats style.css and overwrites the existing file with the formatted output.
Step 3: Format Multiple CSS Files
To format CSS files throughout a project, use:
npx prettier “**/*.css” –write
The command searches for matching CSS files in the project directory and formats them.
Before formatting an entire project, check the matching files and maintain a backup or version-control commit.
Step 4: Check CSS Formatting Without Changing Files
You can check whether CSS files already follow the configured formatting rules:
npx prettier “**/*.css” –check
This reports formatting differences without rewriting the files.
This is useful when multiple developers contribute to the same website.
Can You Beautify CSS Code Online?
Yes. Online CSS beautifiers allow you to format CSS directly in a browser without installing a code editor.
They are particularly useful when working with copied CSS snippets or compressed stylesheets.
A typical CSS beautifier works through the following process:
- Open an online CSS formatter.
- Copy your existing CSS code.
- Paste the code into the input editor.
- Select indentation preferences, if available.
- Click the Beautify or Format button.
- Review the formatted output.
- Copy the result into your stylesheet.
Online tools can save time for small formatting tasks.
However, avoid uploading confidential stylesheets, private project code, or proprietary website information to untrusted online services.
For regular development, a local editor and automated formatter are generally more convenient.
CSS Formatter vs CSS Linter: What Is the Difference?
A CSS formatter and a CSS linter have different purposes.
A formatter organizes code for readability, while a linter checks CSS against configured rules and can identify potential problems.
| Feature | CSS Formatter | CSS Linter |
| Main purpose | Improve code formatting | Identify code-quality issues |
| Indentation | Organizes indentation | Can enforce indentation rules |
| Line breaks | Organizes code layout | Can flag formatting violations |
| CSS syntax | Formats supported syntax | Can report invalid or problematic syntax |
| Naming conventions | Usually preserves names | Can enforce naming rules |
| Maintainability | Improves readability | Helps enforce coding standards |
Prettier is primarily a formatter, while Stylelint is a CSS linter.
For example, Stylelint can help identify problems involving duplicate declarations, invalid syntax, and inconsistent coding conventions, depending on its configuration.
The tools complement each other. Formatting your CSS does not automatically mean the stylesheet is free from coding errors.
Best Practices for Keeping CSS Code Clean
Formatting CSS once is helpful, but maintaining consistent code throughout a project is more important.
Follow these practices:
Use Consistent Indentation
Choose two spaces or four spaces per indentation level and apply the same standard throughout your project.
Avoid Duplicate CSS Declarations
Remove unnecessary duplicate declarations when they are not intentional fallbacks or part of a deliberate cascade.
Group Related Styles
Organize selectors and components into logical sections, such as navigation, buttons, forms, cards, and footer styles.
Use Meaningful Class Names
Use names that explain the purpose of a selector.
For example, prefer .product-card over .box1 or .style-3.
Avoid Unnecessary Use of !important
Excessive use of !important can make the cascade more difficult to understand.
Use appropriate selector specificity and a logical stylesheet structure instead.
Keep Shorthand Properties Consistent
CSS shorthand properties such as margin, padding, and border can simplify declarations.
However, avoid mixing shorthand and longhand properties carelessly because shorthand declarations can reset related property values.
Maintain Responsive Styles Carefully
Group related media queries consistently and avoid scattering contradictory responsive rules throughout the stylesheet.
Use Automated Formatting
Configure Prettier or your preferred editor formatter to maintain consistent formatting.
Validate and Test CSS
Formatting does not guarantee that your stylesheet produces the intended design.
Check selectors, property values, browser support, responsive layouts, and computed styles in browser developer tools.
Common CSS Formatting Mistakes to Avoid
1. Writing Everything on One Line
Compressed CSS makes it harder to locate specific rules and declarations.
Use separate lines for selectors, opening braces, declarations, and closing braces.
2. Mixing Different Indentation Styles
Mixing tabs and spaces throughout the stylesheet creates inconsistent formatting.
Choose one indentation approach and use it consistently.
3. Adding Too Many Unnecessary Comments
Comments should explain complex decisions or organize larger sections. Excessive comments can make a stylesheet harder to read.
4. Confusing Formatting With Error Correction
A formatter improves code presentation, but it does not necessarily correct incorrect property values, unsupported selectors, or layout problems.
Use a linter and browser testing for additional checks.
5. Changing CSS Behavior While Beautifying
Be careful when manually reorganizing CSS.
For example:
.card:hover {
color: red;
}
And:
.card :hover {
color: red;
}
These selectors are different. The first selects an element with the card class when it is hovered. The second selects a hovered descendant of an element with the card class.
Whitespace between CSS selectors can change their meaning.
Always review the output of manual formatting or automated transformations.
6. Reordering CSS Properties Without Understanding the Cascade
Property order can matter when multiple declarations compete for the same property within the cascade.
Do not rearrange declarations simply to make a stylesheet look more organized unless you understand the consequences.
Frequently Asked Questions
1. What is the easiest way to format CSS code?
Using Prettier in Visual Studio Code is one of the easiest approaches. Open the stylesheet, select Format Document, and review the formatted output.
2. Does formatting CSS change website design?
Ordinary formatting changes indentation, line breaks, and whitespace between CSS tokens. These changes generally do not affect styling when the formatter preserves CSS syntax and meaning. However, whitespace inside selectors, strings, and certain expressions can be significant.
3. Can I beautify minified CSS?
Yes. A CSS beautifier or code formatter can expand compressed CSS into readable rulesets and declarations. However, it cannot necessarily restore the original comments, formatting decisions, or property organization.
4. What is the recommended indentation for CSS?
Two spaces per indentation level is a common convention. Four spaces and tabs are also used. Consistency within a project matters more than selecting one universally correct indentation size.
5. Does Prettier fix CSS errors?
Prettier formats supported CSS syntax but is not a complete CSS validation or error-correction tool. Use Stylelint and browser developer tools to identify additional problems.
6. What is the difference between CSS beautification and CSS minification?
CSS beautification expands code into a readable format with indentation and line breaks. CSS minification removes unnecessary characters to produce a more compact stylesheet, usually for production delivery.
Conclusion
Formatting and beautifying CSS code makes stylesheets easier to read, debug, and maintain. Consistent indentation, appropriate spacing, organized declarations, and meaningful comments help developers understand their styles more efficiently.
For small stylesheets, manual formatting may be sufficient. For larger projects, automated tools such as Prettier and Visual Studio Code can maintain consistent formatting with less manual effort.
Remember that formatting, linting, and minification serve different purposes. Use a formatter to organize your CSS, a linter to identify code-quality issues, and appropriate performance tools when preparing stylesheets for production.
Must Read This
How to Format and Beautify CSS Code
CSS Minifier: Benefits and When to Use It
Complete Guide to CSS Gradient Generator
How to Create Beautiful CSS Gradients Easily
CSS Flexbox Playground: How to Master Layouts
CSS Grid vs Flexbox: When to Use Which
How to Generate Box Shadows Visually
CSS Border Radius Generator Explained