diff --git a/README.md b/README.md
index c4c64ea..9068b1e 100644
--- a/README.md
+++ b/README.md
@@ -8,29 +8,31 @@ A simple OOP library for Lua. It has inheritance, metamethods (operators), class
 Quick Look
 ==========
 
-    local class = require 'middleclass'
+```lua
+local class = require 'middleclass'
 
-    local Fruit = class('Fruit') -- 'Fruit' is the class' name
+local Fruit = class('Fruit') -- 'Fruit' is the class' name
 
-    function Fruit:initialize(sweetness)
-      self.sweetness = sweetness
-    end
+function Fruit:initialize(sweetness)
+  self.sweetness = sweetness
+end
 
-    Fruit.static.sweetness_threshold = 5 -- class variable (also admits methods)
+Fruit.static.sweetness_threshold = 5 -- class variable (also admits methods)
 
-    function Fruit:isSweet()
-      return self.sweetness > Fruit.sweetness_threshold
-    end
+function Fruit:isSweet()
+  return self.sweetness > Fruit.sweetness_threshold
+end
 
-    local Lemon = class('Lemon', Fruit) -- subclassing
+local Lemon = class('Lemon', Fruit) -- subclassing
 
-    function Lemon:initialize()
-      Fruit.initialize(self, 1) -- invoking the superclass' initializer
-    end
+function Lemon:initialize()
+  Fruit.initialize(self, 1) -- invoking the superclass' initializer
+end
 
-    local lemon = Lemon:new()
+local lemon = Lemon:new()
 
-    print(lemon:isSweet()) -- false
+print(lemon:isSweet()) -- false
+```
 
 Documentation
 =============
@@ -42,22 +44,28 @@ Installation
 
 Just copy the middleclass.lua file wherever you want it (for example on a lib/ folder). Then write this in any Lua file where you want to use it:
 
-    local class = require 'middleclass'
+```lua
+local class = require 'middleclass'
+```
 
 Specs
 =====
 
 This project uses [busted](http://olivinelabs.com/busted/) for its specs. If you want to run the specs, you will have to install it first. Then just execute the following:
 
-    cd /folder/where/the/spec/folder/is
-    busted
+```bash
+cd /folder/where/the/spec/folder/is
+busted
+```
 
 Performance tests
 =================
 
 Middleclass also comes with a small performance test suite. Just run the following command:
 
-    lua performance/run.lua
+```bash
+lua performance/run.lua
+```
 
 License
 =======
@@ -71,38 +79,45 @@ Middleclass used to expose several global variables on the main scope. It does n
 
 `class` is now returned by `require 'middleclass'`, and it is not set globally. So you can do this:
 
-    local class = require 'middleclass'
-    local MyClass = class('MyClass') -- works as before
+```lua
+local class = require 'middleclass'
+local MyClass = class('MyClass') -- works as before
+```
 
 `Object` is not a global variable any more. But you can get it from `class.Object`
 
-    local class = require 'middleclass'
-    local Object = class.Object
+```lua
+local class = require 'middleclass'
+local Object = class.Object
 
-    print(Object) -- prints 'class Object'
+print(Object) -- prints 'class Object'
+```
 
 The public functions `instanceOf`, `subclassOf` and `includes` have been replaced by `Object.isInstanceOf`, `Object.static.isSubclassOf` and `Object.static.includes`.
 
 Prior to 3.x:
 
-    instanceOf(MyClass, obj)
-    subclassOf(Object, aClass)
-    includes(aMixin, aClass)
+```lua
+instanceOf(MyClass, obj)
+subclassOf(Object, aClass)
+includes(aMixin, aClass)
+```
 
 Since 3.x:
 
-    obj:isInstanceOf(MyClass)
-    aClass:isSubclassOf(Object)
-    aClass:includes(aMixin)
+```lua
+obj:isInstanceOf(MyClass)
+aClass:isSubclassOf(Object)
+aClass:includes(aMixin)
+```
 
 The 3.x code snippet will throw an error if `obj` is not an object, or if `aClass` is not a class (since they will not implement `isInstanceOf`, `isSubclassOf` or `includes`).
 If you are unsure of whether `obj` and `aClass` are an object or a class, you can use the methods in `Object`. They are prepared to work with random types, not just classes and instances:
 
-    Object.isInstanceOf(obj, MyClass)
-    Object.isSubclassOf(aClass, Object)
-    Object.includes(aClass, aMixin)
+```lua
+Object.isInstanceOf(obj, MyClass)
+Object.isSubclassOf(aClass, Object)
+Object.includes(aClass, aMixin)
+```
 
 Notice that the parameter order is not the same now as it was in 2.x. Also note the change in naming: `isInstanceOf` instead of `instanceOf`, and `isSubclassOf` instead of `subclassOf`.
-
-
-