Super-fast Responsive Layouts with Jeet

There are plenty of grid systems available to us today. Designers and front-end developers can experiment with them and choose the ones that best fit their needs. CSS frameworks and boilerplates such as Bootstrap, Foundation, and Skeleton offer grids used by thousands of people.

In this article, I’d like to introduce you to Jeet, an alternative grid system built on CSS preprocessors. Firstly, I’ll cover the basics of it, presenting its core mixins. Then, I’ll show you how to build a project by taking advantage of its features.

What is Jeet

Jeet is a grid system built on top of Sass and Stylus. It consists of powerful mixins and functions you can use to create fast responsive layouts.

Unlike many other grids, Jeet provides a more flexible approach for producing layouts. Here are its main advantages:

1. It doesn’t add any additional markup.
2. It isn’t limited to a specific column size (e.g. 12-column grid).
3. You can use fractions (e.g. 1/4), decimals (e.g. 0.75), or even a combination of them (e.g. 1.5/4) for generating the desired layout.

The grid is designed to work in all major browsers including IE9+. If you want to target previous versions of IE, take a look at the Boy boilerplate.

Getting Started

The grid comes in two flavors, one for Sass(SCSS) and another for Stylus. Depending on the preprocessor you want to use, there’s a different installation method. Jeet’s official page describes all the steps you should follow in order to include the grid in your projects.

Based on the Sass version of it, I set up a demo project. I’ll refer to it in an upcoming section. For now, let’s just look at its basic structure:

jeet-demo/
├── index.html
├── jeet/
│     ├── _functions.scss
│     ├── _grid.scss
│     ├── _settings.scss
│     └── index.scss
├── style.css
└── style.scss

You can grab all the files for this project by visiting this github repository.

At this point it’s time to go through Jeet’s major mixins.

Note: To demonstrate how the mixins work, I’ll use the SCSS syntax.

Container

The center mixin allows you to horizontally center an element. Most of the time, you’ll use this mixin to define the element that will act as the container of your columns. The table below shows its parameters:

Parameter	Description	Default Value
max-width	Set the element’s max-width	1410px
pad	Specify the padding-left and padding-right properties of the element	0

Here’s an example of that mixin:

See the Pen Jeet Grid – container by SitePoint (@SitePoint) on CodePen.

To restore the rules applied by the center mixin, use the uncenter mixin.

Columns with Gutters

To define your columns, Jeet provides the col or column mixin. The following table describes its parameters:

Parameter	Description	Default Value
ratios	Set the element’s width relative to its container’s width	1
offset	Specify the margin-left property of the element	0
cycle	Define a nth (based on the cycle value) column grid	0
uncycle	Undo the grid specified by the cycle variable	0
gutter	Specify the margin-right property of the element	3

The cycle and uncycle variables simplify the process of creating multi-column responsive layouts. Here’s an example:

See the Pen Jeet Grid – columns with gutters by SitePoint (@SitePoint) on CodePen.

Columns without Gutters

In addition to the col/column mixin, there’s also available the span mixin for creating your columns. You can use this one in case you don’t want gutters between them. Here are its parameters:

Parameter	Description	Default Value
ratios	Set the element’s width relative to its container’s width	1
offset	Specify the margin-left property of the element	0
cycle	Define a nth (based on the cycle value) column grid	0
uncycle	Undo the grid specified by the cycle variable	0

Below is an example of that mixin:

See the Pen Jeet Grid – Columns without Gutters by SitePoint (@SitePoint) on CodePen.

Stacked Columns

The stack mixin helps you generate stacked columns. This is a handy feature, especially on small screen sizes, where the layout changes and the elements stack on top of each other. Here are its parameters:

Parameter	Description	Default Value
pad	Specify the padding-left and padding-right properties of the element	0
align	Set (if value=true) the element’s text-align property	false

An example that takes advantage of that behavior is shown below:

See the Pen Jeet Grid – Stacked Columns by SitePoint (@SitePoint) on CodePen.

To restore the rules applied by the stack mixin, use the unstack one.

Column Ordering

Jeet provides the shift mixin for column ordering. The following table shows its parameters:

Parameter	Description	Default Value
ratios	Specify how far the element will be moved compared to its original position	0
col-or-span	Specify whether the element has a gutter or not	column
gutter	Specify the margin-right property of the element	3

You can get an idea of how this mixin works in the following example:

See the Pen Jeet Grid – Column Ordering by SitePoint (@SitePoint) on CodePen.

To restore the rules applied by the shift mixin, use the unshift one.

Absolute Centering

Using the align mixin you can center an element horizontally or/and vertically. In order to take advantage of it, you should also set the type of positioning of the parent element as relative.

The parameter of that mixin is shown below:

Parameter	Description	Default Value
direction	Define the element’s type of alignment	both

Here’s an example:

See the Pen Jeet Grid – Absolute Centering by SitePoint (@SitePoint) on CodePen.

Putting it All Together

Let’s now use Jeet to create the layout of our demo project.

First, we’ll structure the section related to our portfolio.

For small devices (<450px), we want the work items to be stacked. By default, that happens because in the markup we use the figure element, which is a block-level element. Moreover, when the browser window has a width between 450px and 799px, we want two items per row. Finally, for larger screens (≥800px) each row should contain four items.

Here’s our layout based on the last assumption:

Below is a snippet for the relevant HTML:

<div class="portfolio">
    <figure>
        <img src="http://placehold.it/450/ededed/ededed">
        <a href="#">
            <figcaption>Work-1</figcaption>
        </a>
    </figure>
    ...
</div>

Here’s our SCSS code:

@media screen and (min-width: 450px) {
    figure {
        @include col(1/2, $cycle: 2);
    }
}

@media screen and (min-width: 800px) {
    figure {
        @include col(1/4, $cycle: 4, $uncycle: 2);
    }
}

And the compiled CSS:

@media screen and (min-width: 450px) {
    figure {
        float: left;
        width: 48.5%;
        margin-left: 0%;
        margin-right: 3%;
    }

    figure:nth-of-type(2n) {
        float: right;
        margin-right: 0%;
    }
}

@media screen and (min-width: 800px) {
    figure {
        float: left;
        width: 22.75%;
        margin-left: 0%;
        margin-right: 3%;
    }

    figure:nth-of-type(2n) {
        float: left;
        margin-right: 3%;
    }

    figure:nth-of-type(4n) {
        float: right;
        margin-right: 0%;
    }
}

Note: For simplicity, I’ve only included some of the rules from the compiled CSS. To see the complete CSS that Jeet outputs, look at the style.css file.

Let’s work on a second example.

Here we will structure the social links. Each link will occupy one-fourth of their container width. To start, we define the width of their parent element using the center mixin. Then, we set their width taking advantage of the col mixin.

Here’s the desired layout:

Our markup:

<div>
    <a href="#">Twitter</a>
    ...
</div>

The required SCSS:

div {
    @include center(700px);

    a {
        @include col(1/4);
    }
}

And the resulting CSS:

div {
    max-width: 700px;
    margin-right: auto;
    margin-left: auto;
}

div a {
    float: left;
    width: 22.75%;
    margin-left: 0%;
    margin-right: 3%;
}

div a:last-child {
    margin-right: 0%;
}

Note: Again for simplicity, I’ve included just some of the rules from the compiled CSS. To see the complete CSS that Jeet outputs, look at the style.css file.

Conclusion

In this article, I presented Jeet, an alternative grid that helps you create easy and flexible responsive layouts. Then, I went through examples that demonstrated how to use its mixins. I hope you found the tour and this grid system interesting and you might give it a try in any of your upcoming projects.

If you’ve already used Jeet, let us know in the comments below.