Implementing CSS for Older Browsers
Tags: css
Published: 2023-05-05 23:43:00

by [Nweke Emmanuel Manuchimso](https://blog.openreplay.com/authors/nweke-emmanuel-manuchimso)

<blockquote><em>You've just learned about the newest CSS feature and can't wait to incorporate it into your code, but you also need to make it compatible with older browsers, which may be a real nuisance. Normally, this would be the end of your hopes of utilizing contemporary CSS capabilities, but this article shows that this is not the case and that with a little CSS change, it is possible to apply modern CSS without breaking older browsers.</em></blockquote>



This article will examine the small tweaks needed to ensure that outdated browsers are not excluded from newer CSS implementations in this article. CSS feature queries, also known as the `@supports` rule, allow you to apply styles conditionally based on whether a browser supports a particular CSS feature. This can be used to implement modern CSS features without breaking older browsers that do not support them.

To use feature queries, you wrap your CSS styles inside the `@supports` rule and specify the feature you want to check for using the `not` or `and` keywords.

For example, to use the `grid` layout without breaking older browsers, you can use the following code:

```css
@supports (display: grid) {
    /* grid styles here */
  }
```


This will apply the 'grid' style only if the browser supports the 'grid' layout.
Another example is to use the `not` keyword:

```css
@supports not (display: grid) {
  /* fallback styles here */
}
```


This will apply the fallback styles only if the browser does not support the `grid` layout.
You can also chain multiple feature queries together using the `and` keyword:

```css 
@supports (display: grid) and (display: flex) {
  /* styles here */
}
```


This will apply the styles only if the browser supports both `grid` and `flex`.

It's important to note that feature queries are not supported in IE and Edge versions less than 17, so you may need to use JavaScript or a polyfill to provide fallback functionality for those browsers.


## CSS Writing Tips for Modern Browsers with Fallbacks

The best way to write CSS with `fallbacks` to implement modern CSS without ruining older browsers is to use feature detection and [progressive enhancement](https://developer.mozilla.org/en-US/docs/Glossary/Progressive_Enhancement). This involves using modern CSS properties and techniques but also providing fallback styles for older browsers that do not support these features. This can be done by using tools such as [Modernizr](https://modernizr.com/) to detect browser support for specific features and then applying appropriate CSS styles based on the detection results. Additionally, using a CSS preprocessor like Sass or Less can make it easier to manage fallback styles by allowing you to use variables and nested selectors. Another approach is to use CSS Grid and Flexbox with a CSS polyfill for older browsers that don't support them. This will help to ensure that your layout and design will work across all browsers.

Here is an example of how to use CSS `fallbacks` to implement modern CSS without breaking older browsers:

```css
/* Modern CSS */
.example {
    display: flex;
}

/* Fallback for older browsers */
@supports (display: flex) {
    /* Modern CSS */
    .example {
        display: flex;
    }
}
@supports not (display: flex) {
    /* Fallback CSS */
    .example {
        display: block;
    }
}
```
In this example, the modern CSS uses the `display: flex` property, which most modern browsers support. However, older browsers may not support this property. To address this, we use the `@supports` rule to check if the browser supports `display: flex`. If it does, modern CSS is applied, and if it does not, fallback CSS (`display: block` in this case) is applied instead.

Note that this is just one example, you can use this technique with any CSS properties, and you can use it to apply different fallback styles.




<div style="background-color:#efefef; border-radius:8px; padding:10px; display:block;">
<hr/>
<h3><em>Session Replay for Developers</em></h3> 
<p><em>Uncover frustrations, understand bugs and fix slowdowns like never before with <strong><a href="https://github.com/openreplay/openreplay" target="_blank">OpenReplay</a></strong> — an open-source session replay suite for developers. It can be <strong>self-hosted</strong> in minutes, giving you complete control over your customer data.</em></p>
<img alt="OpenReplay" style="margin-top:5px; margin-bottom:5px;" width="768" height="400" src="https://raw.githubusercontent.com/openreplay/openreplay/main/static/openreplay-git-hero.svg" class="astro-UXNKDZ4E" loading="lazy" decoding="async">
<p><em>Happy debugging! <a href="https://openreplay.com" target="_blank">Try using OpenReplay today.</a></em><p>
<hr/>
</div>




## Why and how do CSS fallbacks work?

CSS `fallbacks` work in implementing modern CSS without ruining older browsers because they allow developers to use new CSS features while still providing a functional and visually similar experience for users on older browsers that do not support those features. This is achieved by providing an alternative, or `fallback`, CSS rule that will be applied on older browsers that do not support the newer feature. This allows the website to continue functioning and look good on older browsers while taking advantage of newer CSS features on modern browsers.

One example of using CSS `fallbacks` is using the CSS3 properties for rounded corners and gradients. These properties are not supported on older browsers, so a fallback can be used to provide a similar experience. For example, the developer could use the border-radius property to create rounded corners on modern browsers but provide a fallback by using images or CSS3 border-image property to create the same effect on older browsers.
Another example is the use of CSS Grid and Flexbox, which are not supported on older browsers. The fallback can be used by providing an alternative layout using older layout methods such as floats or `display:table-cell`.

In summary, CSS `fallbacks` allow developers to use modern CSS features while still providing a functional and visually similar experience for users on older browsers that do not support those features. This is achieved by providing alternative CSS rules that will be applied on older browsers that do not support the newer feature. This allows the website to continue functioning and look good on older browsers while taking advantage of newer CSS features on modern browsers.


## Do you need this to implement modern CSS?

No, you do not need CSS to implement modern CSS without ruining older browsers. Various techniques and tools, such as feature detection, polyfills, and fallback styles, can be used to ensure that your website looks and functions correctly on all browsers, including older ones. However, CSS is still a key tool for styling and layout, so it would be difficult to implement a modern website without it.

Additionally, using CSS preprocessors like SASS or LESS and CSS frameworks such as Bootstrap or Foundation can also help in implementing modern CSS in a way that is compatible with older browsers. These tools provide a set of pre-written CSS code that can be easily customized to fit the design of your website while also providing a level of compatibility with older browsers.

Another approach would be using CSS grid and flexbox in a fallback way, where you can use CSS Grid for modern browsers and flexbox as a fallback for older browsers.
Overall, while you don't strictly need CSS to implement modern features without ruining older browsers, it is a core technology for styling and layout, and tools and techniques exist that can help you use it in a backward-compatible way.


## CSS frameworks

Another approach is to use a CSS framework or library such as Bootstrap or Foundation, which provide a set of pre-written CSS classes and JavaScript plugins that work across a wide range of browsers, including older ones. These frameworks often include features such as a responsive grid system and pre-built UI components like buttons and forms, which can save you time and effort when building your website.

Both Bootstrap and Foundation are popular front-end frameworks that can be used to implement modern CSS without ruining older browser compatibility. Here's an example of using Bootstrap to create a basic responsive layout:


```html
<!DOCTYPE html>
<html>
  <head>
    <link
      rel="stylesheet"
      href="https://maxcdn.bootstrapcdn.com/bootstrap/3.3.7/css/bootstrap.min.css"
    />
  </head>

  <body>
    <div class="container">
      <div class="row">
        <div class="col-sm-4">Column 1</div>
        <div class="col-sm-4">Column 2</div>
        <div class="col-sm-4">Column 3</div>
      </div>
    </div>
  </body>
</html>
```


This example uses the Bootstrap grid system to create a layout with three equal-width columns that will automatically stack on smaller screens. The older browser will not understand the latest css so it will fallback to the default styles.

Similarly, here's an example of using Foundation to create a basic responsive layout:

```html
<!DOCTYPE html>
<html>
  <head>
    <link
      rel="stylesheet"
      href="https://cdn.jsdelivr.net/npm/foundation-sites@6.6.3/dist/css/foundation.min.css"
    />
  </head>

  <body>
    <div class="row">
      <div class="small-4 columns">Column 1</div>
      <div class="small-4 columns">Column 2</div>
      <div class="small-4 columns">Column 3</div>
    </div>
  </body>
</html>
```


This is also similar to Bootstrap, where it uses a grid system and also fallback to default styles in older browsers.
Both frameworks also provide a wide range of pre-built UI components and JavaScript plugins that can be easily integrated into your project.

Additionally, you can use tools like [Autoprefixer](https://autoprefixer.github.io/) or [PostCSS](https://postcss.org/) to automatically add vendor prefixes to your CSS, which are necessary for certain CSS properties to work in older browsers. These tools can help you ensure that your CSS is compatible with a wide range of browsers without having to manually add vendor prefixes yourself.


## Conclusion

In summary, feature queries are a potent tool that may be used to create cutting-edge CSS without causing problems for legacy browsers. As a result, you won't have to wait years for browser support to catch up the next time a fun new CSS feature is released before implementing it. Last but not least, it's critical to test your website across a range of browsers and platforms, including older ones, to make sure it functions and appears as expected. This will enable you to find and address any compatibility problems before they have an impact on your users.