diff --git a/README.markdown b/README.markdown
index 08dbe31..0d5771d 100644
--- a/README.markdown
+++ b/README.markdown
@@ -1,6 +1,6 @@
 # Welcome to Triq -- Trifork QuickCheck for Erlang
 
-[![Build Status](https://travis-ci.org/krestenkrab/triq.svg?branch=master)](https://travis-ci.org/krestenkrab/triq) 
+[![Build Status](https://travis-ci.org/triqng/triq.svg?branch=master)](https://travis-ci.org/triqng/triq) 
 
 This is a fork of Triq that is being run under the ZeroMQ Collaberation rules, http://rfc.zeromq.org/spec:22 with the one exception being that it is under the apache licence 
 
@@ -15,39 +15,51 @@
 much better shrinking mechanism, cool C integration, and
 professional support.
 
+## Using Triq
 
-## Installation
+### Installation via package manager
 
-To use `triq`, you download the latest version from
-[here](http://github.com/krestenkrab/triq/downloads), and untar it
-into your erlang lib directory (typically
-`/usr/local/lib/erlang/lib`):
+To use `triq`, you can add it as a project dependency and let your
+package manager of choice handle it:
 
-```sh
-prompt$ cd /usr/local/lib/erlang/lib
-propmt$ tar xvzf triq-0.1.0.tgz
-...
+rebar.config: `{triq, "1.*"}`
+
+erlang.mk: `DEPS = triq`
+
+mix.exs: `{:triq, "~> 1.*"}`
+
+### Installation from source into `$ERL_LIBS`
+
+If you want to make `triq` available globally, you can install it from source
+into your Erlang installation by adding it in one of your `$ERL_LIBS` paths.
+So, it's either somewhere like `/usr/local/lib/lib/erlang/lib` or `$HOME/.erl`.
+
+You can either download a tagged release from
+`https://github.com/triqng/triq/releases` and extract that or clone the git
+repo `https://github.com/triqng/triq` in the target directory. Once that's
+done, cd into the directory and run `./rebar compile` or just `make`.
+
+Now, if you start `erl`, you should be able to call functions from the
+`triq` module.
+
+```
+$ erl
+1> code:which(triq).
+"/usr/local/lib/erlang/lib/triq/ebin/triq.beam"
+2>
 ```
 
-And you're all set.
+### Writing properties with Triq
 
-Or, checkout the triq source code and soft link / copy into your Erlang lib directory:
+To write properties with `triq`, include the header file:
 
-```sh
-prompt$ git clone git://github.com/krestenkrab/triq.git
-prompt$ cd triq
-prompt$ ln -s . /usr/local/lib/erlang/lib/triq-0.1.0
 ```
-
-Next, to use `triq`, include the header file:
-
-```erlang
 -include_lib("triq/include/triq.hrl").
 ```
 
 And you're ready to write property tests.  An example property could be:
 
-```erlang
+```
 prop_append() ->
     ?FORALL({Xs,Ys},{list(int()),list(int())},
             lists:reverse(Xs++Ys)
@@ -57,7 +69,7 @@
 
 To test this property, run `triq:check/1`, thus:
 
-```erlang
+```
 1> triq:check(prop_append()).
 ......................................................................
 ..............................
@@ -68,7 +80,7 @@
 
 If the test fails, it will try to shrink the result; here is an example:
 
-```erlang
+```
 prop_delete() ->
     ?FORALL(L,list(int()),
         ?IMPLIES(L /= [],
@@ -78,7 +90,7 @@
 ```
 
 Which runs like this:
-```erlang
+```
 1> triq:check(triq_tests:prop_delete()).
 x....Failed!
 L=[4,5,5], I=5
@@ -93,7 +105,7 @@
 
 You can get the values used for the failing test with `counterexample`,
 and reuse the same test values with `check/2`:
-```erlang
+```
 3> A = triq:counterexample(triq_tests:xprop_delete()).
 x.xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxFailed!
 L=[3,2,1,1,1], I=1
@@ -117,18 +129,23 @@
 6>
 ```
 
-Modules compiled with the `triq.hrl` header, auto-export all functions named `prop_*`,
-and have a function added called `check/0` which runs `triq:check/1` on all the properties in the module.
+Modules compiled with the `triq.hrl` header, auto-export all functions named
+`prop_*`, and have a function added called `check/0` which runs `triq:check/1`
+on all the properties in the module.
 
-```erlang
+```
 1> mymodule:check().
 ```
 
-A handy addition that I use is to also add an `eunit` test, which tests it:
+You can also instruct `triq` to generate EUnit integration functions which allow
+the module to be treated like an ordinary EUnit tests module. This avoids the need
+for `triq` or generic `qc` support in your build/test tool of choice.
+To achieve that, just make sure to include the attribute `-triq(eunit).` in the module.
+So, the initial `triq.hrl` include would turn into this:
 
-```erlang
-property_test() -> true = check().
 ```
-Which can then automatically be run using your favourite `eunit` runner.
+-include_lib("triq/include/triq.hrl").
+-triq(eunit).
+```
 
 Good luck!