Skip to content

Latest commit

 

History

History
 
 

inuitcss

README.md

inuit.css

inuit.css – v5.0

inuit.css is a powerful little framework designed for serious developers.

It is a Sass based, Object Oriented framework that is full of objects and abstractions. inuit.css provides little-to-no design which means no undoing things, no deleting CSS and no adhering to other peoples’ design decisions.

inuit.css is built on a BEM-style naming convention and honed based on work done by Nicolas Gallagher.

inuit.css is ideally suited to designers who want to focus on the creative and not code, and developers who understand the need for abstraction and an OO approach.

inuit.css gives you design patterns, not design decisions. It features nestable, fluid grids; a double-stranded heading hierarchy; sprites; buttons and a lot, lot more.

Use inuit.css if:

  • You need a powerful library of objects and abstractions.
  • You understand/appreciate the value of OO code and the need for scalability and reuse.
  • You are a confident/competent developer comfortable with OOCSS and Sass, as well as familiarity with OO principles in general.

Do not use inuit.css if:

  • You need a framework that supplies design (I’d recommend Bootstrap for that).

Browser support

inuit.css is a modern framework for modern browsers. It takes advantage of normalize.css and global box-sizing:border-box; (optional). As such, inuit.css is intended for IE8 and above only. The last release to support IE7 was v4.1.5.

The developer

There are a million-and-one different CSS frameworks out there so this rather cringeworthy section is an attempt to validate inuit.css and give it some credibility…

I am Harry Roberts, I am a 22 year old developer and front-end architect from the UK. I work as a Senior UI Developer for BSkyB where it is my job to build scalable front-ends, write internally used CSS frameworks and libraries, and to architect CSS and front-end builds.

I write, tweet and speak about OOCSS, scalable CSS, maintainability, working in large teams, CSS performance, CSS architecture and a whole lot more.

inuit.css is the result of years of my specialism in CSS (as CSS is all I do). It is a collection of design patterns, objects, and abstractions that have been refined and bulletproofed over hours of development across an array of projects of varying sizes. inuit.css is the result of hundreds of hours of work all condensed into one powerful little framework.

Installation

Requires Sass 3.2

inuit.css v5.0+ is designed to be even more advanced than previous versions of your favourite CSS framework! inuit.css’ core library is now intended to be used as a submodule which means you can always get inuit.css’ latest updates without ever having to touch a line of library code.

This works by having this, the inuit.css core library, and the inuit.css-web-template. The web template is very un-opinionated and simply houses your site, however you wish to build it. It has a css/ directory which contains your project-specific variables and any stylesheets that extend inuit.css, as well as housing inuit.css as an updatable submodule. Any of inuit.css’ default settings can be simply overridden from the web template which means you no longer have to edit a single line of the framework (which in turn means that incorporating inuit.css updates is as simple as a $ git pull).

Install via command line (recommended)

The command line install of inuit.css is incredibly simple:

$ git clone --recursive [email protected]:csswizardry/inuit.css-web-template.git your-project-folder
$ cd your-project-folder
$ ./go

What we are doing here is cloning an instance of the inuit.css-web-template and its submodules (that’s what the --recursive does) into a directory which you specify. Next we cd into that directory and run our go script. This script (courtesy of Nick Payne) simply removes the web template’s Git instance and replaces it with a fresh one for your project, whilst also maintaining your inuit.css submodule.

Install via zip

Though not tested, using inuit.css from its GitHub zip should be fairly simple. Using inuit.css from zipped source does mean that you can’t update inuit.css as a submodule, but you may well be able to drop fresh zip files into the css/inuit.css/ directory provided you don’t edit any library code.

Firstly you need to download the web template zip and unpack it to a location of your choosing. Next you need to download the inuit.css core zip and unpack that into css/inuit.css/ in your new project.

Getting started

Once you have your project set up, you should be looking at a directory structure a little like this:

your-project-folder/
    css/
        inuit.css/
        _vars.scss
        style.scss
        watch
    index.html

Your CSS directory holds everything you need to get building:

  • Everything in css/inuit.css/ is library code which should not be edited. If you cd into here you should see that this submodule will initially be on (no branch), this is because the submodule points at a specific commit and not a branch. You can treat this directory like any other Git project which means you can $ git checkout master to get your submodule on the most up-to-date stable version of inuit.css. To grab any new changes simply run $ git pull on the master branch.
  • _vars.scss contains any project variables you need, as well as any overrides you wish to make to the inuit.css library. It also houses feature switches to turn inuit.css’ objects and abstractions on and off as you need them.
  • style.scss is your master Sass stylesheet which will concatenate any other stylesheets from inuit.css and your extensions when it is compiled.
  • watch is a handy little script which makes it easier for you to watch your Sass from the command line; instead of the $ sass --watch ... command, you now need only type $ ./watch and the script will do the rest. Running this will compile your project into style[.min].css.

How inuit.css works

inuit.css works in ‘layers’, not dissimilar to SMACSS. The principle of inuit.css’ architecture is levels of extension; each layer of code extends the layer below.

We start in inuit.css/generic/, with our most generic, low-level styling, things like a clearfix, normalize.css, our reset and any shared styling like margins (for vertical rythmn).

On top of that we lay our base styles, found in inuit.css/base/; these are things like unclassed headings, what our basic forms look like, how simple tables appear. These are all design-free HTML elements that you can extend with your own styles later on.

Next up, in inuit.css/objects/, we have our objects and abstractions; these are all scaffolding type constructs that hold no styling, but do heavy lifting. In here we have things like the media object, the nav abstraction and other unstyled objects that you can use to construct design patterns without design (that bit is left up to you).

Finally we have our helper classes (though these live back in the inuit.css/generic/ directory); these are things like margin helper classes, width classes and other ‘style trumps’ which need to take precedence over any things that have gone before them. These classes are used to modify your objects and abstractions on a case-by-case basis.

Overriding inuit.css’ defaults

inuit.css has a file called _defaults.scss which contains all the Sass variables required for the library to compile without failing. These variables are preset because Sass will error without them, however they are not set in stone, and you are encouranged to override and experiment with them.

It is tempting to modify their values in the inuit.css submodule but this is not the correct method for modifying inuit.css, and in doing so you will prevent yourself from being able to update inuit.css’ core library. The correct procedure is to redefine that variable in _vars.scss found in the inuit.css web template. Let’s take an example…

In inuit.css’ _defaults.scss we find the following:

$h1-size:           36px!default; // .alpha
$h2-size:           30px!default; // .beta
$h3-size:           24px!default; // .gamma
$h4-size:           20px!default; // .delta
$h5-size:           16px!default; // .epsilon
$h6-size:           14px!default; // .zeta

Let’s say we want our h1s to be 48px and not 36px; instead of modifying the value of $h1-size here, pop open your _vars.scss file and add this in the overrides section:

/*------------------------------------*\
    $OVERRIDES
\*------------------------------------*/
/**
 * Place any variables that should override inuit.css’ defaults here.
 */
$h1-size:48px;

Now when you compile your CSS, inuit.css will know to ignore its preset value (that is what !default is for) in favour of your own. By doing things this way you can change the values that inuit.css uses without having to modify inuit.css itself, thus leaving it free to be updated.

In this file you will also see your feature switches needed to turn objects and abstractions on and off. Feature switches are only preset for objects and abstractions; you will not initially find switches for things like $debug-mode in here, but they can be turned on and off by adding an override as outlined above, e.g.:

/*------------------------------------*\
    $OVERRIDES
\*------------------------------------*/
/**
 * Place any variables that should override inuit.css’ defaults here.
 */
$h1-size:48px;
$push:true;
$palm-push:true;

This file can also house any custom variables that you wish to use in extending inuit.css, as covered in the next section.

Extending inuit.css

inuit.css is, by design, a very design-free framework. This means that the style and design of your site is left entirely up to you (as it should be). Because inuit.css gives you lots of customisable foundations, you need to add the final layer: UI.

How you go about this step is largely left up to you, but it is common practice to create another directory in css/ called ui/, leaving you with:

your-project-folder/
    css/
        inuit.css/
        ui/
        _vars.scss
        style.scss 
        watch
    index.html

In here you can place your own Sass files which hold your UI’s CSS, for example:

ui/
    _contact-form.scss
    _footer.scss
    _pricing-table.scss

You then include these from style.scss, like so:

/**
 * She’s all yours, cap’n... Begin importing your stuff here.
 */
//@import "ui/example";
@import "ui/footer";
@import "ui/contact-form";
@import "ui/pricing-table";

Now, when you run $ ./watch, style.scss will be calling:

  1. Your variables
  2. The inuit.css core library (as outlined above)
  3. Your custom/UI CSS

…and building a concatenated stylesheet out of it all. Neat, huh?!

Footprint

Out of the box, inuit.css is very small, however it is imperative that you only ever deploy a minified version of your compiled stylesheet to your live environment. inuit.css compiles stright to minified output by default, but you can change this in watch if you have a build process in place.

It is also highly recommended that you enable gzip compression on any text assets being served from your site; doing so will further reduce the footprint of inuit.css and greatly help your site’s performance.

Documentation

There are no official docs for inuit.css because the code is the documentation. Everything is heavily commented with example HTML. If you struggle with anything please tweet at @inuitcss and/or open an issue and I’ll try help out and use your feedback to improve the documentation.

It is strongly encouraged that you thoroughly read the source of inuit.css’ files, particularly _inuit.scss.

Demos

Although there are no docs as such, there is a dedicated inuit.css jsFiddle account which houses plenty of demos of various aspects of the framework.

Development

You can keep up-to-date with upcoming features, suggestions and fixes by looking at the inuit.css Trello board.

Looking for a little LESS?

Peter Wilson and Nicolas Carlo are maintaining a LESS port of inuit.css: check the GitHub repo.

Using Compass?

Stephen Way is maintaining a Compass port of inuit.css: check the GitHub repo.

Test-drive

If you would like to try inuit.css out before you download anything there is a compiled version on jsFiddle that you are encouraged to fork and play with. Refer back to the source here on GitHub for documentation.

As used by

Using inuit.css?

If you use inuit.css on a live project then tweet at me and I’ll send you some inuit.css stickers!

Support inuit.css

If you use and/or like inuit.css, perhaps you might consider supporting it through Gumroad.

Credits

inuit.css, although produced and maintained by one developer, could not have been possible without inspiration and work from an array of other people.

And probably more…

License

Copyright 2013 Harry Roberts

Licensed under the Apache License, Version 2.0.

inuit.css is the most powerful little framework out there, and it’s ready to go!