diff --git a/AUTHORS b/AUTHORS
new file mode 100644
--- /dev/null
+++ b/AUTHORS
@@ -0,0 +1,3 @@
+Francesco Ariis
+Simon Michael
+José Rafael Vieira
diff --git a/COPYING b/COPYING
new file mode 100644
--- /dev/null
+++ b/COPYING
@@ -0,0 +1,674 @@
+              GNU GENERAL PUBLIC LICENSE
+                Version 3, 29 June 2007
+
+ Copyright (C) 2007 Free Software Foundation, Inc. <http://fsf.org/>
+ Everyone is permitted to copy and distribute verbatim copies
+ of this license document, but changing it is not allowed.
+
+                     Preamble
+
+  The GNU General Public License is a free, copyleft license for
+software and other kinds of works.
+
+  The licenses for most software and other practical works are designed
+to take away your freedom to share and change the works.  By contrast,
+the GNU General Public License is intended to guarantee your freedom to
+share and change all versions of a program--to make sure it remains free
+software for all its users.  We, the Free Software Foundation, use the
+GNU General Public License for most of our software; it applies also to
+any other work released this way by its authors.  You can apply it to
+your programs, too.
+
+  When we speak of free software, we are referring to freedom, not
+price.  Our General Public Licenses are designed to make sure that you
+have the freedom to distribute copies of free software (and charge for
+them if you wish), that you receive source code or can get it if you
+want it, that you can change the software or use pieces of it in new
+free programs, and that you know you can do these things.
+
+  To protect your rights, we need to prevent others from denying you
+these rights or asking you to surrender the rights.  Therefore, you have
+certain responsibilities if you distribute copies of the software, or if
+you modify it: responsibilities to respect the freedom of others.
+
+  For example, if you distribute copies of such a program, whether
+gratis or for a fee, you must pass on to the recipients the same
+freedoms that you received.  You must make sure that they, too, receive
+or can get the source code.  And you must show them these terms so they
+know their rights.
+
+  Developers that use the GNU GPL protect your rights with two steps:
+(1) assert copyright on the software, and (2) offer you this License
+giving you legal permission to copy, distribute and/or modify it.
+
+  For the developers' and authors' protection, the GPL clearly explains
+that there is no warranty for this free software.  For both users' and
+authors' sake, the GPL requires that modified versions be marked as
+changed, so that their problems will not be attributed erroneously to
+authors of previous versions.
+
+  Some devices are designed to deny users access to install or run
+modified versions of the software inside them, although the manufacturer
+can do so.  This is fundamentally incompatible with the aim of
+protecting users' freedom to change the software.  The systematic
+pattern of such abuse occurs in the area of products for individuals to
+use, which is precisely where it is most unacceptable.  Therefore, we
+have designed this version of the GPL to prohibit the practice for those
+products.  If such problems arise substantially in other domains, we
+stand ready to extend this provision to those domains in future versions
+of the GPL, as needed to protect the freedom of users.
+
+  Finally, every program is threatened constantly by software patents.
+States should not allow patents to restrict development and use of
+software on general-purpose computers, but in those that do, we wish to
+avoid the special danger that patents applied to a free program could
+make it effectively proprietary.  To prevent this, the GPL assures that
+patents cannot be used to render the program non-free.
+
+  The precise terms and conditions for copying, distribution and
+modification follow.
+
+                TERMS AND CONDITIONS
+
+  0. Definitions.
+
+  "This License" refers to version 3 of the GNU General Public License.
+
+  "Copyright" also means copyright-like laws that apply to other kinds of
+works, such as semiconductor masks.
+
+  "The Program" refers to any copyrightable work licensed under this
+License.  Each licensee is addressed as "you".  "Licensees" and
+"recipients" may be individuals or organizations.
+
+  To "modify" a work means to copy from or adapt all or part of the work
+in a fashion requiring copyright permission, other than the making of an
+exact copy.  The resulting work is called a "modified version" of the
+earlier work or a work "based on" the earlier work.
+
+  A "covered work" means either the unmodified Program or a work based
+on the Program.
+
+  To "propagate" a work means to do anything with it that, without
+permission, would make you directly or secondarily liable for
+infringement under applicable copyright law, except executing it on a
+computer or modifying a private copy.  Propagation includes copying,
+distribution (with or without modification), making available to the
+public, and in some countries other activities as well.
+
+  To "convey" a work means any kind of propagation that enables other
+parties to make or receive copies.  Mere interaction with a user through
+a computer network, with no transfer of a copy, is not conveying.
+
+  An interactive user interface displays "Appropriate Legal Notices"
+to the extent that it includes a convenient and prominently visible
+feature that (1) displays an appropriate copyright notice, and (2)
+tells the user that there is no warranty for the work (except to the
+extent that warranties are provided), that licensees may convey the
+work under this License, and how to view a copy of this License.  If
+the interface presents a list of user commands or options, such as a
+menu, a prominent item in the list meets this criterion.
+
+  1. Source Code.
+
+  The "source code" for a work means the preferred form of the work
+for making modifications to it.  "Object code" means any non-source
+form of a work.
+
+  A "Standard Interface" means an interface that either is an official
+standard defined by a recognized standards body, or, in the case of
+interfaces specified for a particular programming language, one that
+is widely used among developers working in that language.
+
+  The "System Libraries" of an executable work include anything, other
+than the work as a whole, that (a) is included in the normal form of
+packaging a Major Component, but which is not part of that Major
+Component, and (b) serves only to enable use of the work with that
+Major Component, or to implement a Standard Interface for which an
+implementation is available to the public in source code form.  A
+"Major Component", in this context, means a major essential component
+(kernel, window system, and so on) of the specific operating system
+(if any) on which the executable work runs, or a compiler used to
+produce the work, or an object code interpreter used to run it.
+
+  The "Corresponding Source" for a work in object code form means all
+the source code needed to generate, install, and (for an executable
+work) run the object code and to modify the work, including scripts to
+control those activities.  However, it does not include the work's
+System Libraries, or general-purpose tools or generally available free
+programs which are used unmodified in performing those activities but
+which are not part of the work.  For example, Corresponding Source
+includes interface definition files associated with source files for
+the work, and the source code for shared libraries and dynamically
+linked subprograms that the work is specifically designed to require,
+such as by intimate data communication or control flow between those
+subprograms and other parts of the work.
+
+  The Corresponding Source need not include anything that users
+can regenerate automatically from other parts of the Corresponding
+Source.
+
+  The Corresponding Source for a work in source code form is that
+same work.
+
+  2. Basic Permissions.
+
+  All rights granted under this License are granted for the term of
+copyright on the Program, and are irrevocable provided the stated
+conditions are met.  This License explicitly affirms your unlimited
+permission to run the unmodified Program.  The output from running a
+covered work is covered by this License only if the output, given its
+content, constitutes a covered work.  This License acknowledges your
+rights of fair use or other equivalent, as provided by copyright law.
+
+  You may make, run and propagate covered works that you do not
+convey, without conditions so long as your license otherwise remains
+in force.  You may convey covered works to others for the sole purpose
+of having them make modifications exclusively for you, or provide you
+with facilities for running those works, provided that you comply with
+the terms of this License in conveying all material for which you do
+not control copyright.  Those thus making or running the covered works
+for you must do so exclusively on your behalf, under your direction
+and control, on terms that prohibit them from making any copies of
+your copyrighted material outside their relationship with you.
+
+  Conveying under any other circumstances is permitted solely under
+the conditions stated below.  Sublicensing is not allowed; section 10
+makes it unnecessary.
+
+  3. Protecting Users' Legal Rights From Anti-Circumvention Law.
+
+  No covered work shall be deemed part of an effective technological
+measure under any applicable law fulfilling obligations under article
+11 of the WIPO copyright treaty adopted on 20 December 1996, or
+similar laws prohibiting or restricting circumvention of such
+measures.
+
+  When you convey a covered work, you waive any legal power to forbid
+circumvention of technological measures to the extent such circumvention
+is effected by exercising rights under this License with respect to
+the covered work, and you disclaim any intention to limit operation or
+modification of the work as a means of enforcing, against the work's
+users, your or third parties' legal rights to forbid circumvention of
+technological measures.
+
+  4. Conveying Verbatim Copies.
+
+  You may convey verbatim copies of the Program's source code as you
+receive it, in any medium, provided that you conspicuously and
+appropriately publish on each copy an appropriate copyright notice;
+keep intact all notices stating that this License and any
+non-permissive terms added in accord with section 7 apply to the code;
+keep intact all notices of the absence of any warranty; and give all
+recipients a copy of this License along with the Program.
+
+  You may charge any price or no price for each copy that you convey,
+and you may offer support or warranty protection for a fee.
+
+  5. Conveying Modified Source Versions.
+
+  You may convey a work based on the Program, or the modifications to
+produce it from the Program, in the form of source code under the
+terms of section 4, provided that you also meet all of these conditions:
+
+    a) The work must carry prominent notices stating that you modified
+    it, and giving a relevant date.
+
+    b) The work must carry prominent notices stating that it is
+    released under this License and any conditions added under section
+    7.  This requirement modifies the requirement in section 4 to
+    "keep intact all notices".
+
+    c) You must license the entire work, as a whole, under this
+    License to anyone who comes into possession of a copy.  This
+    License will therefore apply, along with any applicable section 7
+    additional terms, to the whole of the work, and all its parts,
+    regardless of how they are packaged.  This License gives no
+    permission to license the work in any other way, but it does not
+    invalidate such permission if you have separately received it.
+
+    d) If the work has interactive user interfaces, each must display
+    Appropriate Legal Notices; however, if the Program has interactive
+    interfaces that do not display Appropriate Legal Notices, your
+    work need not make them do so.
+
+  A compilation of a covered work with other separate and independent
+works, which are not by their nature extensions of the covered work,
+and which are not combined with it such as to form a larger program,
+in or on a volume of a storage or distribution medium, is called an
+"aggregate" if the compilation and its resulting copyright are not
+used to limit the access or legal rights of the compilation's users
+beyond what the individual works permit.  Inclusion of a covered work
+in an aggregate does not cause this License to apply to the other
+parts of the aggregate.
+
+  6. Conveying Non-Source Forms.
+
+  You may convey a covered work in object code form under the terms
+of sections 4 and 5, provided that you also convey the
+machine-readable Corresponding Source under the terms of this License,
+in one of these ways:
+
+    a) Convey the object code in, or embodied in, a physical product
+    (including a physical distribution medium), accompanied by the
+    Corresponding Source fixed on a durable physical medium
+    customarily used for software interchange.
+
+    b) Convey the object code in, or embodied in, a physical product
+    (including a physical distribution medium), accompanied by a
+    written offer, valid for at least three years and valid for as
+    long as you offer spare parts or customer support for that product
+    model, to give anyone who possesses the object code either (1) a
+    copy of the Corresponding Source for all the software in the
+    product that is covered by this License, on a durable physical
+    medium customarily used for software interchange, for a price no
+    more than your reasonable cost of physically performing this
+    conveying of source, or (2) access to copy the
+    Corresponding Source from a network server at no charge.
+
+    c) Convey individual copies of the object code with a copy of the
+    written offer to provide the Corresponding Source.  This
+    alternative is allowed only occasionally and noncommercially, and
+    only if you received the object code with such an offer, in accord
+    with subsection 6b.
+
+    d) Convey the object code by offering access from a designated
+    place (gratis or for a charge), and offer equivalent access to the
+    Corresponding Source in the same way through the same place at no
+    further charge.  You need not require recipients to copy the
+    Corresponding Source along with the object code.  If the place to
+    copy the object code is a network server, the Corresponding Source
+    may be on a different server (operated by you or a third party)
+    that supports equivalent copying facilities, provided you maintain
+    clear directions next to the object code saying where to find the
+    Corresponding Source.  Regardless of what server hosts the
+    Corresponding Source, you remain obligated to ensure that it is
+    available for as long as needed to satisfy these requirements.
+
+    e) Convey the object code using peer-to-peer transmission, provided
+    you inform other peers where the object code and Corresponding
+    Source of the work are being offered to the general public at no
+    charge under subsection 6d.
+
+  A separable portion of the object code, whose source code is excluded
+from the Corresponding Source as a System Library, need not be
+included in conveying the object code work.
+
+  A "User Product" is either (1) a "consumer product", which means any
+tangible personal property which is normally used for personal, family,
+or household purposes, or (2) anything designed or sold for incorporation
+into a dwelling.  In determining whether a product is a consumer product,
+doubtful cases shall be resolved in favor of coverage.  For a particular
+product received by a particular user, "normally used" refers to a
+typical or common use of that class of product, regardless of the status
+of the particular user or of the way in which the particular user
+actually uses, or expects or is expected to use, the product.  A product
+is a consumer product regardless of whether the product has substantial
+commercial, industrial or non-consumer uses, unless such uses represent
+the only significant mode of use of the product.
+
+  "Installation Information" for a User Product means any methods,
+procedures, authorization keys, or other information required to install
+and execute modified versions of a covered work in that User Product from
+a modified version of its Corresponding Source.  The information must
+suffice to ensure that the continued functioning of the modified object
+code is in no case prevented or interfered with solely because
+modification has been made.
+
+  If you convey an object code work under this section in, or with, or
+specifically for use in, a User Product, and the conveying occurs as
+part of a transaction in which the right of possession and use of the
+User Product is transferred to the recipient in perpetuity or for a
+fixed term (regardless of how the transaction is characterized), the
+Corresponding Source conveyed under this section must be accompanied
+by the Installation Information.  But this requirement does not apply
+if neither you nor any third party retains the ability to install
+modified object code on the User Product (for example, the work has
+been installed in ROM).
+
+  The requirement to provide Installation Information does not include a
+requirement to continue to provide support service, warranty, or updates
+for a work that has been modified or installed by the recipient, or for
+the User Product in which it has been modified or installed.  Access to a
+network may be denied when the modification itself materially and
+adversely affects the operation of the network or violates the rules and
+protocols for communication across the network.
+
+  Corresponding Source conveyed, and Installation Information provided,
+in accord with this section must be in a format that is publicly
+documented (and with an implementation available to the public in
+source code form), and must require no special password or key for
+unpacking, reading or copying.
+
+  7. Additional Terms.
+
+  "Additional permissions" are terms that supplement the terms of this
+License by making exceptions from one or more of its conditions.
+Additional permissions that are applicable to the entire Program shall
+be treated as though they were included in this License, to the extent
+that they are valid under applicable law.  If additional permissions
+apply only to part of the Program, that part may be used separately
+under those permissions, but the entire Program remains governed by
+this License without regard to the additional permissions.
+
+  When you convey a copy of a covered work, you may at your option
+remove any additional permissions from that copy, or from any part of
+it.  (Additional permissions may be written to require their own
+removal in certain cases when you modify the work.)  You may place
+additional permissions on material, added by you to a covered work,
+for which you have or can give appropriate copyright permission.
+
+  Notwithstanding any other provision of this License, for material you
+add to a covered work, you may (if authorized by the copyright holders of
+that material) supplement the terms of this License with terms:
+
+    a) Disclaiming warranty or limiting liability differently from the
+    terms of sections 15 and 16 of this License; or
+
+    b) Requiring preservation of specified reasonable legal notices or
+    author attributions in that material or in the Appropriate Legal
+    Notices displayed by works containing it; or
+
+    c) Prohibiting misrepresentation of the origin of that material, or
+    requiring that modified versions of such material be marked in
+    reasonable ways as different from the original version; or
+
+    d) Limiting the use for publicity purposes of names of licensors or
+    authors of the material; or
+
+    e) Declining to grant rights under trademark law for use of some
+    trade names, trademarks, or service marks; or
+
+    f) Requiring indemnification of licensors and authors of that
+    material by anyone who conveys the material (or modified versions of
+    it) with contractual assumptions of liability to the recipient, for
+    any liability that these contractual assumptions directly impose on
+    those licensors and authors.
+
+  All other non-permissive additional terms are considered "further
+restrictions" within the meaning of section 10.  If the Program as you
+received it, or any part of it, contains a notice stating that it is
+governed by this License along with a term that is a further
+restriction, you may remove that term.  If a license document contains
+a further restriction but permits relicensing or conveying under this
+License, you may add to a covered work material governed by the terms
+of that license document, provided that the further restriction does
+not survive such relicensing or conveying.
+
+  If you add terms to a covered work in accord with this section, you
+must place, in the relevant source files, a statement of the
+additional terms that apply to those files, or a notice indicating
+where to find the applicable terms.
+
+  Additional terms, permissive or non-permissive, may be stated in the
+form of a separately written license, or stated as exceptions;
+the above requirements apply either way.
+
+  8. Termination.
+
+  You may not propagate or modify a covered work except as expressly
+provided under this License.  Any attempt otherwise to propagate or
+modify it is void, and will automatically terminate your rights under
+this License (including any patent licenses granted under the third
+paragraph of section 11).
+
+  However, if you cease all violation of this License, then your
+license from a particular copyright holder is reinstated (a)
+provisionally, unless and until the copyright holder explicitly and
+finally terminates your license, and (b) permanently, if the copyright
+holder fails to notify you of the violation by some reasonable means
+prior to 60 days after the cessation.
+
+  Moreover, your license from a particular copyright holder is
+reinstated permanently if the copyright holder notifies you of the
+violation by some reasonable means, this is the first time you have
+received notice of violation of this License (for any work) from that
+copyright holder, and you cure the violation prior to 30 days after
+your receipt of the notice.
+
+  Termination of your rights under this section does not terminate the
+licenses of parties who have received copies or rights from you under
+this License.  If your rights have been terminated and not permanently
+reinstated, you do not qualify to receive new licenses for the same
+material under section 10.
+
+  9. Acceptance Not Required for Having Copies.
+
+  You are not required to accept this License in order to receive or
+run a copy of the Program.  Ancillary propagation of a covered work
+occurring solely as a consequence of using peer-to-peer transmission
+to receive a copy likewise does not require acceptance.  However,
+nothing other than this License grants you permission to propagate or
+modify any covered work.  These actions infringe copyright if you do
+not accept this License.  Therefore, by modifying or propagating a
+covered work, you indicate your acceptance of this License to do so.
+
+  10. Automatic Licensing of Downstream Recipients.
+
+  Each time you convey a covered work, the recipient automatically
+receives a license from the original licensors, to run, modify and
+propagate that work, subject to this License.  You are not responsible
+for enforcing compliance by third parties with this License.
+
+  An "entity transaction" is a transaction transferring control of an
+organization, or substantially all assets of one, or subdividing an
+organization, or merging organizations.  If propagation of a covered
+work results from an entity transaction, each party to that
+transaction who receives a copy of the work also receives whatever
+licenses to the work the party's predecessor in interest had or could
+give under the previous paragraph, plus a right to possession of the
+Corresponding Source of the work from the predecessor in interest, if
+the predecessor has it or can get it with reasonable efforts.
+
+  You may not impose any further restrictions on the exercise of the
+rights granted or affirmed under this License.  For example, you may
+not impose a license fee, royalty, or other charge for exercise of
+rights granted under this License, and you may not initiate litigation
+(including a cross-claim or counterclaim in a lawsuit) alleging that
+any patent claim is infringed by making, using, selling, offering for
+sale, or importing the Program or any portion of it.
+
+  11. Patents.
+
+  A "contributor" is a copyright holder who authorizes use under this
+License of the Program or a work on which the Program is based.  The
+work thus licensed is called the contributor's "contributor version".
+
+  A contributor's "essential patent claims" are all patent claims
+owned or controlled by the contributor, whether already acquired or
+hereafter acquired, that would be infringed by some manner, permitted
+by this License, of making, using, or selling its contributor version,
+but do not include claims that would be infringed only as a
+consequence of further modification of the contributor version.  For
+purposes of this definition, "control" includes the right to grant
+patent sublicenses in a manner consistent with the requirements of
+this License.
+
+  Each contributor grants you a non-exclusive, worldwide, royalty-free
+patent license under the contributor's essential patent claims, to
+make, use, sell, offer for sale, import and otherwise run, modify and
+propagate the contents of its contributor version.
+
+  In the following three paragraphs, a "patent license" is any express
+agreement or commitment, however denominated, not to enforce a patent
+(such as an express permission to practice a patent or covenant not to
+sue for patent infringement).  To "grant" such a patent license to a
+party means to make such an agreement or commitment not to enforce a
+patent against the party.
+
+  If you convey a covered work, knowingly relying on a patent license,
+and the Corresponding Source of the work is not available for anyone
+to copy, free of charge and under the terms of this License, through a
+publicly available network server or other readily accessible means,
+then you must either (1) cause the Corresponding Source to be so
+available, or (2) arrange to deprive yourself of the benefit of the
+patent license for this particular work, or (3) arrange, in a manner
+consistent with the requirements of this License, to extend the patent
+license to downstream recipients.  "Knowingly relying" means you have
+actual knowledge that, but for the patent license, your conveying the
+covered work in a country, or your recipient's use of the covered work
+in a country, would infringe one or more identifiable patents in that
+country that you have reason to believe are valid.
+
+  If, pursuant to or in connection with a single transaction or
+arrangement, you convey, or propagate by procuring conveyance of, a
+covered work, and grant a patent license to some of the parties
+receiving the covered work authorizing them to use, propagate, modify
+or convey a specific copy of the covered work, then the patent license
+you grant is automatically extended to all recipients of the covered
+work and works based on it.
+
+  A patent license is "discriminatory" if it does not include within
+the scope of its coverage, prohibits the exercise of, or is
+conditioned on the non-exercise of one or more of the rights that are
+specifically granted under this License.  You may not convey a covered
+work if you are a party to an arrangement with a third party that is
+in the business of distributing software, under which you make payment
+to the third party based on the extent of your activity of conveying
+the work, and under which the third party grants, to any of the
+parties who would receive the covered work from you, a discriminatory
+patent license (a) in connection with copies of the covered work
+conveyed by you (or copies made from those copies), or (b) primarily
+for and in connection with specific products or compilations that
+contain the covered work, unless you entered into that arrangement,
+or that patent license was granted, prior to 28 March 2007.
+
+  Nothing in this License shall be construed as excluding or limiting
+any implied license or other defenses to infringement that may
+otherwise be available to you under applicable patent law.
+
+  12. No Surrender of Others' Freedom.
+
+  If conditions are imposed on you (whether by court order, agreement or
+otherwise) that contradict the conditions of this License, they do not
+excuse you from the conditions of this License.  If you cannot convey a
+covered work so as to satisfy simultaneously your obligations under this
+License and any other pertinent obligations, then as a consequence you may
+not convey it at all.  For example, if you agree to terms that obligate you
+to collect a royalty for further conveying from those to whom you convey
+the Program, the only way you could satisfy both those terms and this
+License would be to refrain entirely from conveying the Program.
+
+  13. Use with the GNU Affero General Public License.
+
+  Notwithstanding any other provision of this License, you have
+permission to link or combine any covered work with a work licensed
+under version 3 of the GNU Affero General Public License into a single
+combined work, and to convey the resulting work.  The terms of this
+License will continue to apply to the part which is the covered work,
+but the special requirements of the GNU Affero General Public License,
+section 13, concerning interaction through a network will apply to the
+combination as such.
+
+  14. Revised Versions of this License.
+
+  The Free Software Foundation may publish revised and/or new versions of
+the GNU General Public License from time to time.  Such new versions will
+be similar in spirit to the present version, but may differ in detail to
+address new problems or concerns.
+
+  Each version is given a distinguishing version number.  If the
+Program specifies that a certain numbered version of the GNU General
+Public License "or any later version" applies to it, you have the
+option of following the terms and conditions either of that numbered
+version or of any later version published by the Free Software
+Foundation.  If the Program does not specify a version number of the
+GNU General Public License, you may choose any version ever published
+by the Free Software Foundation.
+
+  If the Program specifies that a proxy can decide which future
+versions of the GNU General Public License can be used, that proxy's
+public statement of acceptance of a version permanently authorizes you
+to choose that version for the Program.
+
+  Later license versions may give you additional or different
+permissions.  However, no additional obligations are imposed on any
+author or copyright holder as a result of your choosing to follow a
+later version.
+
+  15. Disclaimer of Warranty.
+
+  THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY
+APPLICABLE LAW.  EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT
+HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY
+OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO,
+THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+PURPOSE.  THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE PROGRAM
+IS WITH YOU.  SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF
+ALL NECESSARY SERVICING, REPAIR OR CORRECTION.
+
+  16. Limitation of Liability.
+
+  IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
+WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MODIFIES AND/OR CONVEYS
+THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY
+GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE
+USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS OF
+DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD
+PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS),
+EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF
+SUCH DAMAGES.
+
+  17. Interpretation of Sections 15 and 16.
+
+  If the disclaimer of warranty and limitation of liability provided
+above cannot be given local legal effect according to their terms,
+reviewing courts shall apply local law that most closely approximates
+an absolute waiver of all civil liability in connection with the
+Program, unless a warranty or assumption of liability accompanies a
+copy of the Program in return for a fee.
+
+              END OF TERMS AND CONDITIONS
+
+     How to Apply These Terms to Your New Programs
+
+  If you develop a new program, and you want it to be of the greatest
+possible use to the public, the best way to achieve this is to make it
+free software which everyone can redistribute and change under these terms.
+
+  To do so, attach the following notices to the program.  It is safest
+to attach them to the start of each source file to most effectively
+state the exclusion of warranty; and each file should have at least
+the "copyright" line and a pointer to where the full notice is found.
+
+    <one line to give the program's name and a brief idea of what it does.>
+    Copyright (C) <year>  <name of author>
+
+    This program is free software: you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+Also add information on how to contact you by electronic and paper mail.
+
+  If the program does terminal interaction, make it output a short
+notice like this when it starts in an interactive mode:
+
+    <program>  Copyright (C) <year>  <name of author>
+    This program comes with ABSOLUTELY NO WARRANTY; for details type `show w'.
+    This is free software, and you are welcome to redistribute it
+    under certain conditions; type `show c' for details.
+
+The hypothetical commands `show w' and `show c' should show the appropriate
+parts of the General Public License.  Of course, your program's commands
+might be different; for a GUI interface, you would use an "about box".
+
+  You should also get your employer (if you work as a programmer) or school,
+if any, to sign a "copyright disclaimer" for the program, if necessary.
+For more information on this, and how to apply and follow the GNU GPL, see
+<http://www.gnu.org/licenses/>.
+
+  The GNU General Public License does not permit incorporating your program
+into proprietary programs.  If your program is a subroutine library, you
+may consider it more useful to permit linking proprietary applications with
+the library.  If this is what you want to do, use the GNU Lesser General
+Public License instead of this License.  But first, please read
+<http://www.gnu.org/philosophy/why-not-lgpl.html>.
diff --git a/LICENSE b/LICENSE
deleted file mode 100644
--- a/LICENSE
+++ /dev/null
@@ -1,674 +0,0 @@
-              GNU GENERAL PUBLIC LICENSE
-                Version 3, 29 June 2007
-
- Copyright (C) 2007 Free Software Foundation, Inc. <http://fsf.org/>
- Everyone is permitted to copy and distribute verbatim copies
- of this license document, but changing it is not allowed.
-
-                     Preamble
-
-  The GNU General Public License is a free, copyleft license for
-software and other kinds of works.
-
-  The licenses for most software and other practical works are designed
-to take away your freedom to share and change the works.  By contrast,
-the GNU General Public License is intended to guarantee your freedom to
-share and change all versions of a program--to make sure it remains free
-software for all its users.  We, the Free Software Foundation, use the
-GNU General Public License for most of our software; it applies also to
-any other work released this way by its authors.  You can apply it to
-your programs, too.
-
-  When we speak of free software, we are referring to freedom, not
-price.  Our General Public Licenses are designed to make sure that you
-have the freedom to distribute copies of free software (and charge for
-them if you wish), that you receive source code or can get it if you
-want it, that you can change the software or use pieces of it in new
-free programs, and that you know you can do these things.
-
-  To protect your rights, we need to prevent others from denying you
-these rights or asking you to surrender the rights.  Therefore, you have
-certain responsibilities if you distribute copies of the software, or if
-you modify it: responsibilities to respect the freedom of others.
-
-  For example, if you distribute copies of such a program, whether
-gratis or for a fee, you must pass on to the recipients the same
-freedoms that you received.  You must make sure that they, too, receive
-or can get the source code.  And you must show them these terms so they
-know their rights.
-
-  Developers that use the GNU GPL protect your rights with two steps:
-(1) assert copyright on the software, and (2) offer you this License
-giving you legal permission to copy, distribute and/or modify it.
-
-  For the developers' and authors' protection, the GPL clearly explains
-that there is no warranty for this free software.  For both users' and
-authors' sake, the GPL requires that modified versions be marked as
-changed, so that their problems will not be attributed erroneously to
-authors of previous versions.
-
-  Some devices are designed to deny users access to install or run
-modified versions of the software inside them, although the manufacturer
-can do so.  This is fundamentally incompatible with the aim of
-protecting users' freedom to change the software.  The systematic
-pattern of such abuse occurs in the area of products for individuals to
-use, which is precisely where it is most unacceptable.  Therefore, we
-have designed this version of the GPL to prohibit the practice for those
-products.  If such problems arise substantially in other domains, we
-stand ready to extend this provision to those domains in future versions
-of the GPL, as needed to protect the freedom of users.
-
-  Finally, every program is threatened constantly by software patents.
-States should not allow patents to restrict development and use of
-software on general-purpose computers, but in those that do, we wish to
-avoid the special danger that patents applied to a free program could
-make it effectively proprietary.  To prevent this, the GPL assures that
-patents cannot be used to render the program non-free.
-
-  The precise terms and conditions for copying, distribution and
-modification follow.
-
-                TERMS AND CONDITIONS
-
-  0. Definitions.
-
-  "This License" refers to version 3 of the GNU General Public License.
-
-  "Copyright" also means copyright-like laws that apply to other kinds of
-works, such as semiconductor masks.
-
-  "The Program" refers to any copyrightable work licensed under this
-License.  Each licensee is addressed as "you".  "Licensees" and
-"recipients" may be individuals or organizations.
-
-  To "modify" a work means to copy from or adapt all or part of the work
-in a fashion requiring copyright permission, other than the making of an
-exact copy.  The resulting work is called a "modified version" of the
-earlier work or a work "based on" the earlier work.
-
-  A "covered work" means either the unmodified Program or a work based
-on the Program.
-
-  To "propagate" a work means to do anything with it that, without
-permission, would make you directly or secondarily liable for
-infringement under applicable copyright law, except executing it on a
-computer or modifying a private copy.  Propagation includes copying,
-distribution (with or without modification), making available to the
-public, and in some countries other activities as well.
-
-  To "convey" a work means any kind of propagation that enables other
-parties to make or receive copies.  Mere interaction with a user through
-a computer network, with no transfer of a copy, is not conveying.
-
-  An interactive user interface displays "Appropriate Legal Notices"
-to the extent that it includes a convenient and prominently visible
-feature that (1) displays an appropriate copyright notice, and (2)
-tells the user that there is no warranty for the work (except to the
-extent that warranties are provided), that licensees may convey the
-work under this License, and how to view a copy of this License.  If
-the interface presents a list of user commands or options, such as a
-menu, a prominent item in the list meets this criterion.
-
-  1. Source Code.
-
-  The "source code" for a work means the preferred form of the work
-for making modifications to it.  "Object code" means any non-source
-form of a work.
-
-  A "Standard Interface" means an interface that either is an official
-standard defined by a recognized standards body, or, in the case of
-interfaces specified for a particular programming language, one that
-is widely used among developers working in that language.
-
-  The "System Libraries" of an executable work include anything, other
-than the work as a whole, that (a) is included in the normal form of
-packaging a Major Component, but which is not part of that Major
-Component, and (b) serves only to enable use of the work with that
-Major Component, or to implement a Standard Interface for which an
-implementation is available to the public in source code form.  A
-"Major Component", in this context, means a major essential component
-(kernel, window system, and so on) of the specific operating system
-(if any) on which the executable work runs, or a compiler used to
-produce the work, or an object code interpreter used to run it.
-
-  The "Corresponding Source" for a work in object code form means all
-the source code needed to generate, install, and (for an executable
-work) run the object code and to modify the work, including scripts to
-control those activities.  However, it does not include the work's
-System Libraries, or general-purpose tools or generally available free
-programs which are used unmodified in performing those activities but
-which are not part of the work.  For example, Corresponding Source
-includes interface definition files associated with source files for
-the work, and the source code for shared libraries and dynamically
-linked subprograms that the work is specifically designed to require,
-such as by intimate data communication or control flow between those
-subprograms and other parts of the work.
-
-  The Corresponding Source need not include anything that users
-can regenerate automatically from other parts of the Corresponding
-Source.
-
-  The Corresponding Source for a work in source code form is that
-same work.
-
-  2. Basic Permissions.
-
-  All rights granted under this License are granted for the term of
-copyright on the Program, and are irrevocable provided the stated
-conditions are met.  This License explicitly affirms your unlimited
-permission to run the unmodified Program.  The output from running a
-covered work is covered by this License only if the output, given its
-content, constitutes a covered work.  This License acknowledges your
-rights of fair use or other equivalent, as provided by copyright law.
-
-  You may make, run and propagate covered works that you do not
-convey, without conditions so long as your license otherwise remains
-in force.  You may convey covered works to others for the sole purpose
-of having them make modifications exclusively for you, or provide you
-with facilities for running those works, provided that you comply with
-the terms of this License in conveying all material for which you do
-not control copyright.  Those thus making or running the covered works
-for you must do so exclusively on your behalf, under your direction
-and control, on terms that prohibit them from making any copies of
-your copyrighted material outside their relationship with you.
-
-  Conveying under any other circumstances is permitted solely under
-the conditions stated below.  Sublicensing is not allowed; section 10
-makes it unnecessary.
-
-  3. Protecting Users' Legal Rights From Anti-Circumvention Law.
-
-  No covered work shall be deemed part of an effective technological
-measure under any applicable law fulfilling obligations under article
-11 of the WIPO copyright treaty adopted on 20 December 1996, or
-similar laws prohibiting or restricting circumvention of such
-measures.
-
-  When you convey a covered work, you waive any legal power to forbid
-circumvention of technological measures to the extent such circumvention
-is effected by exercising rights under this License with respect to
-the covered work, and you disclaim any intention to limit operation or
-modification of the work as a means of enforcing, against the work's
-users, your or third parties' legal rights to forbid circumvention of
-technological measures.
-
-  4. Conveying Verbatim Copies.
-
-  You may convey verbatim copies of the Program's source code as you
-receive it, in any medium, provided that you conspicuously and
-appropriately publish on each copy an appropriate copyright notice;
-keep intact all notices stating that this License and any
-non-permissive terms added in accord with section 7 apply to the code;
-keep intact all notices of the absence of any warranty; and give all
-recipients a copy of this License along with the Program.
-
-  You may charge any price or no price for each copy that you convey,
-and you may offer support or warranty protection for a fee.
-
-  5. Conveying Modified Source Versions.
-
-  You may convey a work based on the Program, or the modifications to
-produce it from the Program, in the form of source code under the
-terms of section 4, provided that you also meet all of these conditions:
-
-    a) The work must carry prominent notices stating that you modified
-    it, and giving a relevant date.
-
-    b) The work must carry prominent notices stating that it is
-    released under this License and any conditions added under section
-    7.  This requirement modifies the requirement in section 4 to
-    "keep intact all notices".
-
-    c) You must license the entire work, as a whole, under this
-    License to anyone who comes into possession of a copy.  This
-    License will therefore apply, along with any applicable section 7
-    additional terms, to the whole of the work, and all its parts,
-    regardless of how they are packaged.  This License gives no
-    permission to license the work in any other way, but it does not
-    invalidate such permission if you have separately received it.
-
-    d) If the work has interactive user interfaces, each must display
-    Appropriate Legal Notices; however, if the Program has interactive
-    interfaces that do not display Appropriate Legal Notices, your
-    work need not make them do so.
-
-  A compilation of a covered work with other separate and independent
-works, which are not by their nature extensions of the covered work,
-and which are not combined with it such as to form a larger program,
-in or on a volume of a storage or distribution medium, is called an
-"aggregate" if the compilation and its resulting copyright are not
-used to limit the access or legal rights of the compilation's users
-beyond what the individual works permit.  Inclusion of a covered work
-in an aggregate does not cause this License to apply to the other
-parts of the aggregate.
-
-  6. Conveying Non-Source Forms.
-
-  You may convey a covered work in object code form under the terms
-of sections 4 and 5, provided that you also convey the
-machine-readable Corresponding Source under the terms of this License,
-in one of these ways:
-
-    a) Convey the object code in, or embodied in, a physical product
-    (including a physical distribution medium), accompanied by the
-    Corresponding Source fixed on a durable physical medium
-    customarily used for software interchange.
-
-    b) Convey the object code in, or embodied in, a physical product
-    (including a physical distribution medium), accompanied by a
-    written offer, valid for at least three years and valid for as
-    long as you offer spare parts or customer support for that product
-    model, to give anyone who possesses the object code either (1) a
-    copy of the Corresponding Source for all the software in the
-    product that is covered by this License, on a durable physical
-    medium customarily used for software interchange, for a price no
-    more than your reasonable cost of physically performing this
-    conveying of source, or (2) access to copy the
-    Corresponding Source from a network server at no charge.
-
-    c) Convey individual copies of the object code with a copy of the
-    written offer to provide the Corresponding Source.  This
-    alternative is allowed only occasionally and noncommercially, and
-    only if you received the object code with such an offer, in accord
-    with subsection 6b.
-
-    d) Convey the object code by offering access from a designated
-    place (gratis or for a charge), and offer equivalent access to the
-    Corresponding Source in the same way through the same place at no
-    further charge.  You need not require recipients to copy the
-    Corresponding Source along with the object code.  If the place to
-    copy the object code is a network server, the Corresponding Source
-    may be on a different server (operated by you or a third party)
-    that supports equivalent copying facilities, provided you maintain
-    clear directions next to the object code saying where to find the
-    Corresponding Source.  Regardless of what server hosts the
-    Corresponding Source, you remain obligated to ensure that it is
-    available for as long as needed to satisfy these requirements.
-
-    e) Convey the object code using peer-to-peer transmission, provided
-    you inform other peers where the object code and Corresponding
-    Source of the work are being offered to the general public at no
-    charge under subsection 6d.
-
-  A separable portion of the object code, whose source code is excluded
-from the Corresponding Source as a System Library, need not be
-included in conveying the object code work.
-
-  A "User Product" is either (1) a "consumer product", which means any
-tangible personal property which is normally used for personal, family,
-or household purposes, or (2) anything designed or sold for incorporation
-into a dwelling.  In determining whether a product is a consumer product,
-doubtful cases shall be resolved in favor of coverage.  For a particular
-product received by a particular user, "normally used" refers to a
-typical or common use of that class of product, regardless of the status
-of the particular user or of the way in which the particular user
-actually uses, or expects or is expected to use, the product.  A product
-is a consumer product regardless of whether the product has substantial
-commercial, industrial or non-consumer uses, unless such uses represent
-the only significant mode of use of the product.
-
-  "Installation Information" for a User Product means any methods,
-procedures, authorization keys, or other information required to install
-and execute modified versions of a covered work in that User Product from
-a modified version of its Corresponding Source.  The information must
-suffice to ensure that the continued functioning of the modified object
-code is in no case prevented or interfered with solely because
-modification has been made.
-
-  If you convey an object code work under this section in, or with, or
-specifically for use in, a User Product, and the conveying occurs as
-part of a transaction in which the right of possession and use of the
-User Product is transferred to the recipient in perpetuity or for a
-fixed term (regardless of how the transaction is characterized), the
-Corresponding Source conveyed under this section must be accompanied
-by the Installation Information.  But this requirement does not apply
-if neither you nor any third party retains the ability to install
-modified object code on the User Product (for example, the work has
-been installed in ROM).
-
-  The requirement to provide Installation Information does not include a
-requirement to continue to provide support service, warranty, or updates
-for a work that has been modified or installed by the recipient, or for
-the User Product in which it has been modified or installed.  Access to a
-network may be denied when the modification itself materially and
-adversely affects the operation of the network or violates the rules and
-protocols for communication across the network.
-
-  Corresponding Source conveyed, and Installation Information provided,
-in accord with this section must be in a format that is publicly
-documented (and with an implementation available to the public in
-source code form), and must require no special password or key for
-unpacking, reading or copying.
-
-  7. Additional Terms.
-
-  "Additional permissions" are terms that supplement the terms of this
-License by making exceptions from one or more of its conditions.
-Additional permissions that are applicable to the entire Program shall
-be treated as though they were included in this License, to the extent
-that they are valid under applicable law.  If additional permissions
-apply only to part of the Program, that part may be used separately
-under those permissions, but the entire Program remains governed by
-this License without regard to the additional permissions.
-
-  When you convey a copy of a covered work, you may at your option
-remove any additional permissions from that copy, or from any part of
-it.  (Additional permissions may be written to require their own
-removal in certain cases when you modify the work.)  You may place
-additional permissions on material, added by you to a covered work,
-for which you have or can give appropriate copyright permission.
-
-  Notwithstanding any other provision of this License, for material you
-add to a covered work, you may (if authorized by the copyright holders of
-that material) supplement the terms of this License with terms:
-
-    a) Disclaiming warranty or limiting liability differently from the
-    terms of sections 15 and 16 of this License; or
-
-    b) Requiring preservation of specified reasonable legal notices or
-    author attributions in that material or in the Appropriate Legal
-    Notices displayed by works containing it; or
-
-    c) Prohibiting misrepresentation of the origin of that material, or
-    requiring that modified versions of such material be marked in
-    reasonable ways as different from the original version; or
-
-    d) Limiting the use for publicity purposes of names of licensors or
-    authors of the material; or
-
-    e) Declining to grant rights under trademark law for use of some
-    trade names, trademarks, or service marks; or
-
-    f) Requiring indemnification of licensors and authors of that
-    material by anyone who conveys the material (or modified versions of
-    it) with contractual assumptions of liability to the recipient, for
-    any liability that these contractual assumptions directly impose on
-    those licensors and authors.
-
-  All other non-permissive additional terms are considered "further
-restrictions" within the meaning of section 10.  If the Program as you
-received it, or any part of it, contains a notice stating that it is
-governed by this License along with a term that is a further
-restriction, you may remove that term.  If a license document contains
-a further restriction but permits relicensing or conveying under this
-License, you may add to a covered work material governed by the terms
-of that license document, provided that the further restriction does
-not survive such relicensing or conveying.
-
-  If you add terms to a covered work in accord with this section, you
-must place, in the relevant source files, a statement of the
-additional terms that apply to those files, or a notice indicating
-where to find the applicable terms.
-
-  Additional terms, permissive or non-permissive, may be stated in the
-form of a separately written license, or stated as exceptions;
-the above requirements apply either way.
-
-  8. Termination.
-
-  You may not propagate or modify a covered work except as expressly
-provided under this License.  Any attempt otherwise to propagate or
-modify it is void, and will automatically terminate your rights under
-this License (including any patent licenses granted under the third
-paragraph of section 11).
-
-  However, if you cease all violation of this License, then your
-license from a particular copyright holder is reinstated (a)
-provisionally, unless and until the copyright holder explicitly and
-finally terminates your license, and (b) permanently, if the copyright
-holder fails to notify you of the violation by some reasonable means
-prior to 60 days after the cessation.
-
-  Moreover, your license from a particular copyright holder is
-reinstated permanently if the copyright holder notifies you of the
-violation by some reasonable means, this is the first time you have
-received notice of violation of this License (for any work) from that
-copyright holder, and you cure the violation prior to 30 days after
-your receipt of the notice.
-
-  Termination of your rights under this section does not terminate the
-licenses of parties who have received copies or rights from you under
-this License.  If your rights have been terminated and not permanently
-reinstated, you do not qualify to receive new licenses for the same
-material under section 10.
-
-  9. Acceptance Not Required for Having Copies.
-
-  You are not required to accept this License in order to receive or
-run a copy of the Program.  Ancillary propagation of a covered work
-occurring solely as a consequence of using peer-to-peer transmission
-to receive a copy likewise does not require acceptance.  However,
-nothing other than this License grants you permission to propagate or
-modify any covered work.  These actions infringe copyright if you do
-not accept this License.  Therefore, by modifying or propagating a
-covered work, you indicate your acceptance of this License to do so.
-
-  10. Automatic Licensing of Downstream Recipients.
-
-  Each time you convey a covered work, the recipient automatically
-receives a license from the original licensors, to run, modify and
-propagate that work, subject to this License.  You are not responsible
-for enforcing compliance by third parties with this License.
-
-  An "entity transaction" is a transaction transferring control of an
-organization, or substantially all assets of one, or subdividing an
-organization, or merging organizations.  If propagation of a covered
-work results from an entity transaction, each party to that
-transaction who receives a copy of the work also receives whatever
-licenses to the work the party's predecessor in interest had or could
-give under the previous paragraph, plus a right to possession of the
-Corresponding Source of the work from the predecessor in interest, if
-the predecessor has it or can get it with reasonable efforts.
-
-  You may not impose any further restrictions on the exercise of the
-rights granted or affirmed under this License.  For example, you may
-not impose a license fee, royalty, or other charge for exercise of
-rights granted under this License, and you may not initiate litigation
-(including a cross-claim or counterclaim in a lawsuit) alleging that
-any patent claim is infringed by making, using, selling, offering for
-sale, or importing the Program or any portion of it.
-
-  11. Patents.
-
-  A "contributor" is a copyright holder who authorizes use under this
-License of the Program or a work on which the Program is based.  The
-work thus licensed is called the contributor's "contributor version".
-
-  A contributor's "essential patent claims" are all patent claims
-owned or controlled by the contributor, whether already acquired or
-hereafter acquired, that would be infringed by some manner, permitted
-by this License, of making, using, or selling its contributor version,
-but do not include claims that would be infringed only as a
-consequence of further modification of the contributor version.  For
-purposes of this definition, "control" includes the right to grant
-patent sublicenses in a manner consistent with the requirements of
-this License.
-
-  Each contributor grants you a non-exclusive, worldwide, royalty-free
-patent license under the contributor's essential patent claims, to
-make, use, sell, offer for sale, import and otherwise run, modify and
-propagate the contents of its contributor version.
-
-  In the following three paragraphs, a "patent license" is any express
-agreement or commitment, however denominated, not to enforce a patent
-(such as an express permission to practice a patent or covenant not to
-sue for patent infringement).  To "grant" such a patent license to a
-party means to make such an agreement or commitment not to enforce a
-patent against the party.
-
-  If you convey a covered work, knowingly relying on a patent license,
-and the Corresponding Source of the work is not available for anyone
-to copy, free of charge and under the terms of this License, through a
-publicly available network server or other readily accessible means,
-then you must either (1) cause the Corresponding Source to be so
-available, or (2) arrange to deprive yourself of the benefit of the
-patent license for this particular work, or (3) arrange, in a manner
-consistent with the requirements of this License, to extend the patent
-license to downstream recipients.  "Knowingly relying" means you have
-actual knowledge that, but for the patent license, your conveying the
-covered work in a country, or your recipient's use of the covered work
-in a country, would infringe one or more identifiable patents in that
-country that you have reason to believe are valid.
-
-  If, pursuant to or in connection with a single transaction or
-arrangement, you convey, or propagate by procuring conveyance of, a
-covered work, and grant a patent license to some of the parties
-receiving the covered work authorizing them to use, propagate, modify
-or convey a specific copy of the covered work, then the patent license
-you grant is automatically extended to all recipients of the covered
-work and works based on it.
-
-  A patent license is "discriminatory" if it does not include within
-the scope of its coverage, prohibits the exercise of, or is
-conditioned on the non-exercise of one or more of the rights that are
-specifically granted under this License.  You may not convey a covered
-work if you are a party to an arrangement with a third party that is
-in the business of distributing software, under which you make payment
-to the third party based on the extent of your activity of conveying
-the work, and under which the third party grants, to any of the
-parties who would receive the covered work from you, a discriminatory
-patent license (a) in connection with copies of the covered work
-conveyed by you (or copies made from those copies), or (b) primarily
-for and in connection with specific products or compilations that
-contain the covered work, unless you entered into that arrangement,
-or that patent license was granted, prior to 28 March 2007.
-
-  Nothing in this License shall be construed as excluding or limiting
-any implied license or other defenses to infringement that may
-otherwise be available to you under applicable patent law.
-
-  12. No Surrender of Others' Freedom.
-
-  If conditions are imposed on you (whether by court order, agreement or
-otherwise) that contradict the conditions of this License, they do not
-excuse you from the conditions of this License.  If you cannot convey a
-covered work so as to satisfy simultaneously your obligations under this
-License and any other pertinent obligations, then as a consequence you may
-not convey it at all.  For example, if you agree to terms that obligate you
-to collect a royalty for further conveying from those to whom you convey
-the Program, the only way you could satisfy both those terms and this
-License would be to refrain entirely from conveying the Program.
-
-  13. Use with the GNU Affero General Public License.
-
-  Notwithstanding any other provision of this License, you have
-permission to link or combine any covered work with a work licensed
-under version 3 of the GNU Affero General Public License into a single
-combined work, and to convey the resulting work.  The terms of this
-License will continue to apply to the part which is the covered work,
-but the special requirements of the GNU Affero General Public License,
-section 13, concerning interaction through a network will apply to the
-combination as such.
-
-  14. Revised Versions of this License.
-
-  The Free Software Foundation may publish revised and/or new versions of
-the GNU General Public License from time to time.  Such new versions will
-be similar in spirit to the present version, but may differ in detail to
-address new problems or concerns.
-
-  Each version is given a distinguishing version number.  If the
-Program specifies that a certain numbered version of the GNU General
-Public License "or any later version" applies to it, you have the
-option of following the terms and conditions either of that numbered
-version or of any later version published by the Free Software
-Foundation.  If the Program does not specify a version number of the
-GNU General Public License, you may choose any version ever published
-by the Free Software Foundation.
-
-  If the Program specifies that a proxy can decide which future
-versions of the GNU General Public License can be used, that proxy's
-public statement of acceptance of a version permanently authorizes you
-to choose that version for the Program.
-
-  Later license versions may give you additional or different
-permissions.  However, no additional obligations are imposed on any
-author or copyright holder as a result of your choosing to follow a
-later version.
-
-  15. Disclaimer of Warranty.
-
-  THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY
-APPLICABLE LAW.  EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT
-HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY
-OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO,
-THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-PURPOSE.  THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE PROGRAM
-IS WITH YOU.  SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF
-ALL NECESSARY SERVICING, REPAIR OR CORRECTION.
-
-  16. Limitation of Liability.
-
-  IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
-WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MODIFIES AND/OR CONVEYS
-THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY
-GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE
-USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS OF
-DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD
-PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS),
-EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF
-SUCH DAMAGES.
-
-  17. Interpretation of Sections 15 and 16.
-
-  If the disclaimer of warranty and limitation of liability provided
-above cannot be given local legal effect according to their terms,
-reviewing courts shall apply local law that most closely approximates
-an absolute waiver of all civil liability in connection with the
-Program, unless a warranty or assumption of liability accompanies a
-copy of the Program in return for a fee.
-
-              END OF TERMS AND CONDITIONS
-
-     How to Apply These Terms to Your New Programs
-
-  If you develop a new program, and you want it to be of the greatest
-possible use to the public, the best way to achieve this is to make it
-free software which everyone can redistribute and change under these terms.
-
-  To do so, attach the following notices to the program.  It is safest
-to attach them to the start of each source file to most effectively
-state the exclusion of warranty; and each file should have at least
-the "copyright" line and a pointer to where the full notice is found.
-
-    <one line to give the program's name and a brief idea of what it does.>
-    Copyright (C) <year>  <name of author>
-
-    This program is free software: you can redistribute it and/or modify
-    it under the terms of the GNU General Public License as published by
-    the Free Software Foundation, either version 3 of the License, or
-    (at your option) any later version.
-
-    This program is distributed in the hope that it will be useful,
-    but WITHOUT ANY WARRANTY; without even the implied warranty of
-    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-    GNU General Public License for more details.
-
-    You should have received a copy of the GNU General Public License
-    along with this program.  If not, see <http://www.gnu.org/licenses/>.
-
-Also add information on how to contact you by electronic and paper mail.
-
-  If the program does terminal interaction, make it output a short
-notice like this when it starts in an interactive mode:
-
-    <program>  Copyright (C) <year>  <name of author>
-    This program comes with ABSOLUTELY NO WARRANTY; for details type `show w'.
-    This is free software, and you are welcome to redistribute it
-    under certain conditions; type `show c' for details.
-
-The hypothetical commands `show w' and `show c' should show the appropriate
-parts of the General Public License.  Of course, your program's commands
-might be different; for a GUI interface, you would use an "about box".
-
-  You should also get your employer (if you work as a programmer) or school,
-if any, to sign a "copyright disclaimer" for the program, if necessary.
-For more information on this, and how to apply and follow the GNU GPL, see
-<http://www.gnu.org/licenses/>.
-
-  The GNU General Public License does not permit incorporating your program
-into proprietary programs.  If your program is a subroutine library, you
-may consider it more useful to permit linking proprietary applications with
-the library.  If this is what you want to do, use the GNU Lesser General
-Public License instead of this License.  But first, please read
-<http://www.gnu.org/philosophy/why-not-lgpl.html>.
diff --git a/NEWS b/NEWS
new file mode 100644
--- /dev/null
+++ b/NEWS
@@ -0,0 +1,441 @@
+1.9.4.0
+-------
+
+- Thanks to José Rafael Vieira, ansi-terminal-game now sports an API for
+  efficient dense-grid drawing.  `Cell` is exported, along with functions
+  to create Cell`s
+
+    creaCell, colorCell, rgbColorCell, paletteColorCell,
+    boldCell, reverseCell
+
+  The most important function is
+
+    cellsPlane :: Width -> Height -> [(Coords, Cell)] -> Plane
+
+  which merges the cells into a `Plane` in a single pass.
+  Many thanks to José!
+
+
+1.9.3.0
+-------
+
+- Bump ansi-terminal 1.1. Due to the introduction of hNowSupportsANSI,
+  older ansi-terminal support has been dropped. If you rely on them,
+  contact me.
+- Released on mer 7 feb 2024, 17:44:31
+
+1.9.2.0
+-------
+
+- This version of a-t-g introduces convenience file-embedding functions
+  `embedFile` and `embedDir`.
+  An example on how this can be useful: suppose you are working on an ASCII
+  map using `tiled` map editor. You could save the map in a `data/map` and
+  then with `embedFile`
+
+      {-# LANGUAGE TemplateHaskell #-}
+
+      mapBS :: ByteString
+      mapBS = $(embedFile "data/map/gamma-labs.map")
+
+      gammaLabs :: GameMap
+      gammaLabs = parseMap mapBS
+
+  having it as a pure value in your program, and being able to ship a
+  single binary instead of a zipped archive.
+  `unpack :: ByteString -> String` and the `ByteString` type itself are
+  also re-exported as helpers.
+
+1.9.1.3
+-------
+
+- Bump hsped
+- dom 14 mag 2023, 14:58:31
+
+1.9.1.2
+-------
+
+- Bump ansi-terminal, fix hspec bounds.
+- Minor documentation fixes.
+- Released dom 14 mag 2023, 12:13:07.
+
+
+1.9.1.1
+-------
+
+- New git repository home, browse it at
+    http://www.ariis.it/static/repos/stagit/ansi-terminal-game
+
+1.9.1.0
+-------
+
+- This version of ansi-terminal-game introduces new ways to describe
+  colours: RGB and xterm colours. You can find a description of the
+  API in the “Non-standard colors” section of Haddock.
+  The new functions and types are are
+      data Colour a
+      rgbColor, paletteColor, sRGB24, sRGB, sRGB24read     -- RGB
+      xterm6LevelRGB, xterm24LevelGray, xtermSystem,       -- xterm
+  Enticing as they are, they are supported only by a minority of
+  terminals/multiplexers, so use them only when you are sure of the
+  terminal you are targetting.
+  This change was proposed /and/ implemented by José Rafael Vieira,
+  whom I thank.
+- Fixed a bug on `balls` example (thanks Andread Abel).
+- The haskell tiny game competition is over
+      https://github.com/haskell-game/tiny-games-hs
+  a number of games were made with ansi-terminal-game.
+- Released mer 1 mar 2023, 06:34:52
+
+1.9.0.0
+-------
+
+tl;dr and migration guide:
+- This version of ansi-terminal-games has a new signature for logic
+  function:
+      gLogicFunction :: GEnv -> s -> Event -> Either r s
+- Notice the `Either r s`: `Left` means “game is over”; `Right`means
+  “game continues”.
+- To migrate a project to 1.9.0.0 you should:
+    - Adjust logic function to incorporate those changes.
+    - Get rid of your `quitFunction` in your `Game`.
+    - Modify every `Game s` to `Game s ()`.
+
+Breaking changes:
+- This version changes the logic function from
+      gLogicFunction :: GEnv -> s -> Event -> s
+  to
+      gLogicFunction :: GEnv -> s -> Event -> Either r s
+  `Either r s` is a way to explicitly state whether the game is over
+  not not. If you return `Left $ …` then the game will stop, if you
+  return `Right $ …` your game will continue.
+- the `r` stands for `result` and is present in the type constructor
+  too:
+      Game s r  -- A game with state `s` which will,
+                -- upon exit, return a result `r`.
+- Usually r is () (as simple games do not care about end results,
+  they just quit to terminal). But there are cases (games embedded
+  in a larger program, a set of minigames, high scores) where you
+  want to return something and this is the way to do it.
+- Many other functions have had a slight change of signature to
+  accomodate this change
+      playGame :: Game s r -> IO r
+      narrateGame :: Game s r -> GRec -> IO ()
+      testGame :: Game s -> GRec -> Either s r
+  I will spend some second on the test function. A game tested in
+  a pure environment will end in two ways: a) by reaching Left
+  (proper end game) b) by exhausting the input stream.
+  In case b) we cannot return a result `r`, but just a half-baked
+  ingame state. This is very useful for testing purposes.
+  A trick that I do is this: record events with `recordGame` and
+  then press Ctrl-C midgame. This way the stream is cut and I will
+  get a `Right` state when running `testGame`. I can then analyse
+  the resulting state.
+- Functions have been deleted too
+      playGame :: Game s -> IO s
+  is no more
+- And new functions were introduced:
+    playGame_ :: Game s r -> IO ()      -- discard result
+- The change was suggested by Gergő Érdi, whom I thank.
+  The rationale was to improve ergonomics for the game-makes, I
+  welcome feedback from you.
+- Released mar 28 feb 2023, 20:23:02
+
+Other changes:
+- Clarified KeyPress and Tick behaviour. tl;dr: *all* keypresses are
+  recorded and fed to your game-logic function. If your played manages
+  to type the Divine Comedy in the space of a Tick, all those characters
+  are recorded, not just one.
+  If your game is running faster when keys are pressed, that probably
+  means you are updating some world variables on `KeyPress` events too,
+  while you should do that only on `Tick` events.
+
+1.8.1.0
+-------
+
+- Fixed hcat, vcat, stringPlane, stringPlane documentation to match
+  behaviour (i.e. they do not error on empty strong/list).
+- Now `subPlane` too does not throw an exception when called with
+  inconsistent coordinates, but returns a transparent 1×1 plane.
+- Introduced `MalformedGRec` exception for when `readRecord` fails.
+- Provided instructions for hot-reloading a game running in normal
+  (interactive) mode with various means (tmux, urxvt, etc.).
+  Check `example/MainHotReload.hs`.
+- Introduced RGB and term colours (patch by José Rafael Vieira).
+- Added AUTHORS.
+
+1.8.0.0
+-------
+
+- Fixed testing facilities `recordGame`, `testGame`, `narrateGame` and
+  similar functions. `testGame` in particular is able to precisely
+  emulate recorded environment (so if your game has a bug only at a
+  specific size, `testGame` will now catch it).
+  Check `cabal run -f alone-playback examples ` to see a replay in action
+  and `test/Terminal/Game/Layer/ImperativeSpec.hs` for pure test ideas.
+- Added information on how to have an hot-reload mode, albeit only for
+  non-interactive game replays. Check `example/MainHotReload.hs` if
+  interested.
+- Added a new exception, `DisplayTooSmall`, which expands gracefully to
+  a “please resize your terminal” message to the player if uncaught.
+  Nothing changes if you do not already use `asserTermDims`.
+- `assertTermDims` is now curries (`Width -> Height -> IO ()` instead
+  of `Dimensions -> IO ()`) to better fit the rest of the API.
+- Modified behaviour of functions `vcat`, `hcat`, `stringPlane`,
+  `stringPlaneTrans`. They will not error on empty list, rather return
+  a transparent, 1×1 plane.
+- Changed licence and changes files to COPYING and NEWS.
+
+1.7.0.0
+-------
+
+- After some feedback from library users, I decided to eliminate
+  `simpleGame` from the API.
+  To reiterate hte migration guide, if your type was:
+
+    Game 80 24 13 initState logicFun drawFun quitFun
+    -- or
+    -- simpleGame (80, 24) 13 initState logicFun drawFun quitFun
+
+  You just need to modify it like this:
+
+    Game 13 initState
+                (const logicFun)
+                (\e s -> centerFull e $ drawFun s)
+                quitFun
+        -- notice how we lost `80 24`. You can still have a screen size
+        -- check with `assertTermDims`, as described below.
+- Added `blankPlaneFull` and `centerFull` convenience functions (to work
+  with GEnv terminal dimensions).
+- Added assertTermDims, a quick way to check your user terminal is big
+  enough at the start of the game.
+- minimal blitting optimisation (you should be able to see a 1–2
+  FPS improvement).
+- improved documentation on various functions.
+
+1.6.0.2
+-------
+
+- lun 15 nov 2021, 02:21:08
+- more doc tweaking
+
+1.6.0.1
+-------
+
+- released lun 15 nov 2021, 00:35:41
+- minor documentation / spelling fixes
+
+1.6.0.0
+-------
+
+Summary and tl;dr migration guide:
+- This version introduces a breaking changes in the main way to make
+  a `Game`. I will detail the changes below, but first a three-lines
+  migration guide:
+    the only thing you should have to do is to replace your `Game`
+    data constructor with `simpleGame` smart constructor, and substitute
+    the first to `c` `r` arguments (col/row) with a `(c, r)` tuple.
+  And of course, if you are interested in displaying FPS and adapt to
+  screen size modifications at game-time (“liquid” layout), read along!
+
+Changes:
+- This version introduces GEnv, a structure that exposes current frame
+  rate (in FPS) and current terminal size (in Width, Height).
+- `GEnv` is added as a parameter to logic and draw functions, which
+  now have these signatures:
+    gLogicFunction :: GEnv -> s -> Event -> slightly
+    gDrawFunction :: GEnv -> s -> plane
+- If you do not want to dabble with GEnv, you can still use `simpleGame`
+  smart constructor, which mimicks the old `Game`. `simpleGame` has some
+  nice defaults:
+    - if the terminal is too small it will ask the player to resize it
+      (even in the middle of the game), blocking any input;
+    - if the terminal is bigger, it will paste `Plane` in the middle
+      of the screen.
+- For this reason, `DisplayTooSmall` exception exists no more.
+- the new `Game` does not have those defaults, but allows you to get
+  creative with screen resizes, e.g. accomodating as much gameworld
+  as possible etc. Check `cabal run -f examples balls` and resize the
+  screen to see it in action.
+- Minor change: I have introduced a `Dimensions` alias for
+  `(Width, Height)`.
+
+Future work:
+- these changes lay the path for an even more general `Game` type,
+  adding effects like reading form a game configuration, writing to it
+  etc.
+  I would like to have these wrapped in a pure interface (maybe à la
+  Response/Request? Maybe callbacks?) and for sure want them to be
+  composable with current test scaffolding (testGame,
+  narrateGame, etc.). It will not be easy to design; if are reading
+  this and have any suggestion, please write to me.
+
+Released dom 14 nov 2021, 20:25:19
+
+1.5.0.0
+-------
+
+- `timers-tick` has released a new version: all timers function (creaTimer,
+  creaBoolTimer, creaTimerLoop, creaBoolTimerLoop, creaAnimation,
+  creaLoopAnimation, ticks) are slightly more robust now (will `error`
+  on nonsenical arguments, e.g. frame duration <1).
+  This should not impact any of your current projects, it just makes
+  catching bugs easier.
+- Removed `getFrames` from Animation interface.
+- Updated `Random` interface to fit the new `random`. This is a breaking
+  change but it should be easy to fix by updating your `Random` constraints
+  to `UniformRange`.
+  Be mindful that `recordGame` could play slightly differently, as the
+  update function for the StdGen in `random` has changed.
+- Removed `getRandomList` from Random interface.
+- Added `pickRandom` to Random interface.
+- Removed unuseful `creaStaticAnimation` from Animation interface.
+- Released mar 9 nov 2021, 15:56:14.
+
+1.4.0.0
+-------
+
+- Fixed an annoying bug that made a game run slower than expected on
+  low TPS. Now if you select 5 ticks per second, you can rest assured
+  that after 50 ticks, 5 seconds have elapsed.
+- Renamed `FPS` to `TPS` (ticks per second); highlight logic speed is
+  constant timewise on all machines, while FPS might be different on
+  differently efficient terminals.
+  This will allow in future releases to provide a function to easily
+  calculate actual FPS of the game.
+- Added alternative origin combinators `%^>`, `%.<`, `%.>`; they are
+  useful when you want to — e.g. — «paste a plane one row from
+  bottom-right corner».
+
+1.3.0.0
+-------
+
+- `displaySize` and `playGame`/`playGameS` now throw an exception
+  (of type `ATGException`) instead of `error`ing. These exeptions are
+  `CannotGetDisplaySize` and `DisplayTooSmall`; they are synchronous,
+  for easier catching. (requested by sm)
+- Released sab 16 ott 2021, 21:09:22
+
+1.2.1.0
+-------
+
+- Fixed textBox, textBoxHyphen bug (boxes were not transparent, contrary
+  to what stated in docs) (reported by sm).
+- Released lun 11 ott 2021, 22:29:40
+
+1.2.0.0
+-------
+
+- Added textBoxHyphen and textBoxHyphenLiquid and a handful of `Hypenator`s.
+  This will allow you to have autohyphenation in textboxes. Compare:
+    (normal textbox)                       (hyphenated textbox)
+    Rimasi un po’ a meditare nel buio      Rimasi un po’ a meditare nel buio
+    velato appena dal barlume azzurrino    velato appena dal barlume azzurrino
+    del fornello a gas, su cui             del fornello a gas, su cui sobbol-
+    sobbollliva quieta la pentola.         liva quieta la pentola.
+- Switched `Width`, `Height`, `Row`, `Col` from `Integer` to `Int`.
+  This is unfortunate, but will make playing with `base` simpler. I will
+  switch it back once `Prelude` handles both integers appropriately
+  or exports the relevant function. (request by sm)
+- Changed signature for `box`, `textBox` and `textBoxLiquid`. Now
+  width/height parameters come *before* the character/string. E.g.:
+    textBoxLiquid :: String -> Width -> Plane  -- this was before
+    textBoxLiquid :: Width -> String -> Plane  -- this is now
+  This felt more ergonomic while writing games.
+- `paperPlane` is now `planePaper` (to respect SVO order)
+
+1.1.1.0
+-------
+
+- Added (***) (centre blit) (request by sm)
+- Released gio 30 set 2021, 12:29:22
+
+1.1.0.0
+-------
+
+- Added Plane justapoxition functions (===, |||, vcat, hcat).
+- Added `word` and and `textBoxLiquid` drawing functions.
+- Added `subPlane`, `displaySize` Plane functions.
+- Removed unused `trimPlane`.
+- Sanitized non-ASCII chars on Win32 console.
+- Wed 03 Feb 2021 18:41:20 CET
+
+1.0.0.0
+-------
+
+- Milestone release.
+- Beefed up documentation.
+- Released Sun 08 Dec 2019 04:19:33 CET
+
+0.7.2.0
+-------
+
+- Fixed 0.7.1.0 unbumped dependency.
+- Released Fri 22 Nov 2019 16:51:25 CET
+
+0.7.1.0
+-------
+
+- Fixed 0.7.0.0 (deprecated) interface.
+- Released Fri 22 Nov 2019 14:51:40 CET
+
+0.7.0.0
+-------
+
+- Simplified Animation interface (breaking changes).
+- Added `creaLoopAnimation` and `creaStaticAnimation`.
+- Released Fri 22 Nov 2019 14:40:44 CET
+
+0.6.1.0
+-------
+
+- Reworked Timers/Animations interface and documentation.
+- Added `lapse` (for Timers/Animations).
+- Released Fri 22 Nov 2019 01:03:37 CET
+
+0.6.0.1
+-------
+
+- Add public repo (requested by sm).
+- Released Tue 19 Nov 2019 22:38:34 CET
+
+0.6.0.0
+-------
+
+- Add random generation functions.
+- Released Sun 10 Nov 2019 13:44:32 CET
+
+0.5.0.0
+-------
+
+- Add `setupGame` to setup games before playtesting (skip menus, etc.).
+- Fixed screen corruption on Windows.
+- Released Fri 08 Nov 2019 13:52:39 CET
+
+0.4.0.0
+-------
+
+- Exposed new functions in API.
+- Greatly improved haddock documentation.
+- Released Tue 25 Jun 2019 16:08:53 CEST
+
+0.2.1.0
+-------
+
+- Improved haddock documentation a bit.
+- Cleanup runs regardless of exception.
+- Released on Sun 18 Mar 2018 03:04:07 CET.
+
+0.2.0.0
+-------
+
+- Added dependencies constraints.
+- Removed internal module.
+- Fixed changelog.
+- Released on Fri 16 Mar 2018 00:42:41 CET.
+
+0.1.0.0
+-------
+
+- Initial release.
+- Released on Fri 16 Mar 2018 00:33:18 CET.
diff --git a/README b/README
new file mode 100644
--- /dev/null
+++ b/README
@@ -0,0 +1,52 @@
+==================
+ansi-terminal-game
+==================
+
+`ansi-terminal-game` is a library for creating games in a terminal setting.
+
+Goals
+-----
+
+- be cross platform (linux/win/mac). If you plan to have your executable
+  unix only, I invite you to check brick [1] or other, more expressive
+  libraries.
+- be simple: no curses/ncurses/pdcurses/etc. dependencies, all
+  functionality built on a standard input / ANSI terminal base.
+
+[1] http://hackage.haskell.org/package/brick
+
+Learn
+-----
+
+- run the basic example with `cabal new-run -f examples alone`;
+- check the source in `examples/Alone.hs`;
+- open the 'Terminal.Game' haddock documentation (start reading from
+  `data Game`).
+
+A full game can be found at:
+
+    http://www.ariis.it/static/articles/venzone/page.html
+
+Other games made with a-t-g
+---------------------------
+
+- caverunner:
+    https://github.com/simonmichael/games/blob/main/caverunner/caverunner.hs
+- pigafetta: http://www.ariis.it/link/repos/pigafetta/
+- avoidance: https://sabadev.xyz/avoidance_game
+
+If you want yours to be added to this list, write to me.
+
+Contact
+-------
+
+For any feedback or report, contact me at:
+
+    http://ariis.it/static/articles/mail/page.html
+
+Contributing
+------------
+
+browse repo: http://www.ariis.it/static/repos/stagit/ansi-terminal-game/
+Upload your modifications somewhere and send me an email (<fa-ml@ariis.it>).
+
diff --git a/ansi-terminal-game.cabal b/ansi-terminal-game.cabal
--- a/ansi-terminal-game.cabal
+++ b/ansi-terminal-game.cabal
@@ -1,55 +1,80 @@
 name:                ansi-terminal-game
-version:             0.2.1.0
-synopsis:            sdl-like functions for terminal applications, based on
-                     ansi-terminal
+version:             1.9.4.0
+synopsis:            cross-platform library for terminal games
 description:         Library which aims to replicate standard 2d game
                      functions (blit, ticks, timers, etc.) in a terminal
-                     setting.
+                     setting; features double buffering to optimise
+                     performance.
                      Aims to be cross compatible (based on "ansi-terminal",
                      no unix-only dependencies), practical.
-                     This is a proof of concept release, used to implement
-                     @http://www.ariis.it/static/articles/animascii/page.html@
-                     . See example folder for some minimal programs.
-homepage:            none-yet
+                     See @examples@ folder for some minimal programs.  A
+                     full game: <http://www.ariis.it/static/articles/venzone/page.html venzone>.
+homepage:            http://www.ariis.it/static/articles/libraries/page.html#ansi-terminal-game
 license:             GPL-3
-license-file:        LICENSE
-author:              Francesco Ariis
+license-file:        COPYING
+author:              Francesco Ariis et al. (see AUTHORS)
 maintainer:          fa-ml@ariis.it
-copyright:           © 2017-2018 Francesco Ariis
+copyright:           © 2017-2023 Francesco Ariis et al.
 category:            Game
 build-type:          Simple
-extra-source-files:  changes.txt
-cabal-version:       >=1.10
+extra-source-files:  README,
+                     NEWS,
+                     AUTHORS,
+                     test/records/alone-record-test.gr,
+                     test/records/alone-record-left.gr,
+                     test/records/balls-dims.gr,
+                     test/records/balls-slow.gr
+cabal-version:       >= 1.10
 
-flag example
+flag examples
   description:       builds examples
   default:           False
 
+source-repository head
+    type:     git
+    location: http://www.ariis.it/static/repos/stagit/ansi-terminal-game/
+
 library
   exposed-modules:     Terminal.Game
-  other-modules:       Terminal.Game.ANSI,
-                       Terminal.Game.Plane,
+  other-modules:       Terminal.Game.Animation,
+                       Terminal.Game.Character,
                        Terminal.Game.Draw,
-                       Terminal.Game.Animation,
-                       Terminal.Game.Input,
+                       Terminal.Game.Layer.Imperative,
+                       Terminal.Game.Layer.Object,
+                       Terminal.Game.Layer.Object.GameIO,
+                       Terminal.Game.Layer.Object.Interface,
+                       Terminal.Game.Layer.Object.IO,
+                       Terminal.Game.Layer.Object.Narrate,
+                       Terminal.Game.Layer.Object.Primitive,
+                       Terminal.Game.Layer.Object.Record,
+                       Terminal.Game.Layer.Object.Test,
+                       Terminal.Game.Plane,
+                       Terminal.Game.Random,
                        Terminal.Game.Timer,
-                       Terminal.Game.GameLoop
                        Terminal.Game.Utils
   build-depends:       base == 4.*,
-                       ansi-terminal == 0.8.*,
+                       ansi-terminal >= 1.0 && < 1.2,
                        array == 0.5.*,
-                       bytestring == 0.10.*,
+                       bytestring >= 0.10 && < 0.13,
                        cereal == 0.5.*,
-                       clock == 0.7.*,
-                       linebreak == 1.0.*,
+                       clock >= 0.7 && < 0.9,
+                       containers >= 0.6 && < 0.9,
+                       exceptions == 0.10.*,
+                       file-embed >= 0.0.15 && < 0.1,
+                       linebreak == 1.1.*,
+                       mintty == 0.1.*,
+                       mtl >= 2.2 && < 2.4,
+                       QuickCheck >= 2.13 && < 2.18,
+                       random >= 1.2 && < 1.4,
                        split == 0.2.*,
                        terminal-size == 0.3.*,
-                       timers-tick == 0.4.*
+                       unidecode >= 0.1.0 && < 0.2,
+                       timers-tick > 0.5 && < 0.6,
+                       colour >= 2.3.6 && < 2.4
   hs-source-dirs:      src
   default-language:    Haskell2010
+  ghc-options:         -Wall
 
-  -- horrible horrible horrible hack to make unbuffered input
-  -- work on Windows
   if os(windows)
     hs-source-dirs: platform-dep/windows
   if !os(windows)
@@ -57,29 +82,114 @@
 
 test-suite test
   default-language:    Haskell2010
-  ghc-options:         -Wall
-  HS-Source-Dirs:      test, src
+  hs-Source-Dirs:      test, src, example
   main-is:             Test.hs
-  build-depends:       base==4.*,
-                       array,
-                       linebreak
+  other-modules:       Alone,
+                       Balls,
+                       Terminal.Game,
+                       Terminal.Game.Animation,
+                       Terminal.Game.Character,
+                       Terminal.Game.Draw,
+                       Terminal.Game.DrawSpec,
+                       Terminal.Game.Layer.Imperative,
+                       Terminal.Game.Layer.ImperativeSpec,
+                       Terminal.Game.Layer.Object,
+                       Terminal.Game.Layer.Object.GameIO,
+                       Terminal.Game.Layer.Object.Interface,
+                       Terminal.Game.Layer.Object.IO,
+                       Terminal.Game.Layer.Object.Narrate,
+                       Terminal.Game.Layer.Object.Primitive,
+                       Terminal.Game.Layer.Object.Record,
+                       Terminal.Game.Layer.Object.Test,
+                       Terminal.Game.Layer.Object.TestSpec,
+                       Terminal.Game.Utils,
+                       Terminal.Game.Plane,
+                       Terminal.Game.PlaneSpec
+                       Terminal.Game.Random,
+                       Terminal.Game.RandomSpec
+  build-depends:       base == 4.*,
+                       ansi-terminal >= 1.0 && < 1.2,
+                       array == 0.5.*,
+                       bytestring >= 0.10 && < 0.13,
+                       cereal == 0.5.*,
+                       clock >= 0.7 && < 0.9,
+                       containers >= 0.6 && < 0.9,
+                       exceptions == 0.10.*,
+                       file-embed >= 0.0.15 && < 0.1,
+                       linebreak == 1.1.*,
+                       mintty == 0.1.*,
+                       mtl >= 2.2 && < 2.4,
+                       QuickCheck >= 2.13 && < 2.18,
+                       random >= 1.2 && < 1.4,
+                       split == 0.2.*,
+                       terminal-size == 0.3.*,
+                       unidecode >= 0.1.0 && < 0.2,
+                       timers-tick > 0.5 && < 0.6,
+                       colour >= 2.3.6 && < 2.4
                        -- the above plus hspec
-                       , hspec
+                       , hspec >= 2.10.1 && < 2.12
+  build-tool-depends:  hspec-discover:hspec-discover
   type:                exitcode-stdio-1.0
+  ghc-options:         -Wall
 
-executable alone-in-a-room
-    if flag(example)
-      build-depends:    base == 4.*,
-                        ansi-terminal-game
+  if os(windows)
+    hs-source-dirs: platform-dep/windows
+  if !os(windows)
+    hs-source-dirs: platform-dep/non-win
+
+executable alone
+    if flag(examples)
+      build-depends:  base == 4.*,
+                      ansi-terminal-game
     else
-      buildable:        False
+      buildable:      False
 
     hs-source-dirs:   example
-    main-is:          Alone.hs
+    main-is:          MainAlone.hs
+    other-modules:    Alone
     default-language: Haskell2010
-    -- With the -threaded option, only foreign calls with the unsafe
-    -- attribute will block all other threads.
-    -- TODO [breaking] [severe] [u:3] senza threaded non compila sin windows
-    -- required on win before ghc 8.4?
     ghc-options:      -threaded
+                      -Wall
 
+executable alone-playback
+    if flag(examples)
+      build-depends:  base == 4.*,
+                      ansi-terminal-game,
+                      temporary == 1.3.*
+    else
+      buildable:      False
+
+    hs-source-dirs:   example
+    main-is:          MainPlayback.hs
+    other-modules:    Alone
+    default-language: Haskell2010
+    ghc-options:      -threaded
+                      -Wall
+
+executable balls
+    if flag(examples)
+      build-depends:  base == 4.*,
+                      ansi-terminal-game
+    else
+      buildable:      False
+
+    hs-source-dirs:   example
+    main-is:          MainBalls.hs
+    other-modules:    Balls
+    default-language: Haskell2010
+    ghc-options:      -threaded
+                      -Wall
+
+executable hot-reload
+    if flag(examples)
+      build-depends:  base == 4.*,
+                      ansi-terminal-game
+    else
+      buildable:      False
+
+    hs-source-dirs:   example
+    main-is:          MainHotReload.hs
+    other-modules:    Alone
+    default-language: Haskell2010
+    ghc-options:      -threaded
+                      -Wall
diff --git a/changes.txt b/changes.txt
deleted file mode 100644
--- a/changes.txt
+++ /dev/null
@@ -1,20 +0,0 @@
-0.2.1.0
--------
-
-- Improved haddock documentation a bit.
-- Cleanup runs regardless of exception.
-- Released on Sun 18 Mar 2018 03:04:07 CET.
-
-0.2.0.0
--------
-
-- Added dependencies constraints.
-- Removed internal module.
-- Fixed changelog.
-- Released on Fri 16 Mar 2018 00:42:41 CET.
-
-0.1.0.0
--------
-
-- Initial release.
-- Released on Fri 16 Mar 2018 00:33:18 CET.
diff --git a/example/Alone.hs b/example/Alone.hs
--- a/example/Alone.hs
+++ b/example/Alone.hs
@@ -1,40 +1,46 @@
-module Main where
+module Alone where
 
--- alone in a room: a scary game
--- vai a dormire
--- scary room
--- escape
--- blink exit, blink enemies
--- pit
--- randomly generated
+-- Alone in a room, game definition (logic & draw)
+-- run with: cabal new-run -f examples alone
 
 import Terminal.Game
 
-main :: IO ()
-main = gameLoop "Alone in a room"
-                (GameState (10, 10) Stop False)
-                logicFun
-                drawFun
-                (\gs -> gsQuit gs)
-                5
+import qualified Data.Tuple as T
 
--- STATE --
+-- game specification
+aloneInARoom :: Game MyState ()
+aloneInARoom = Game 13                       -- ticks per second
+                    (MyState (10, 10) Stop)  -- init state
+                    (\_ s e -> logicFun s e) -- logic function
+                    (\r s -> centerFull r $
+                               drawFun s)    -- draw function
 
-data GameState = GameState { gsCoord :: (Integer, Integer),
-                             gsMove  :: Move,
-                             gsQuit  :: Bool }
+sizeCheck :: IO ()
+sizeCheck = let (w, h) = T.swap . snd $ boundaries
+            in assertTermDims w h
 
+-------------------------------------------------------------------------------
+-- Types
+
+data MyState = MyState { gsCoord :: Coords,
+                         gsMove  :: Move }
+             deriving (Show, Eq)
+
 data Move = N | S | E | W | Stop
           deriving (Show, Eq)
 
-logicFun :: GameState -> Maybe Char -> IO GameState
-logicFun gs               (Just 'q') = return $ gs { gsQuit = True }
-logicFun (GameState cs m b) Nothing  =
-               return $ GameState (pos m cs) m b -- xxx duplicated code
-logicFun (GameState cs m b) (Just c) =
-            let m' = move m c
-            in return $ GameState (pos m' cs) m' b
+boundaries :: (Coords, Coords)
+boundaries = ((1, 1), (24, 80))
 
+-------------------------------------------------------------------------------
+-- Logic
+
+logicFun :: MyState -> Event -> Either () MyState
+logicFun _ (KeyPress 'q') = Left ()
+logicFun gs Tick          = Right $ gs { gsCoord = pos (gsMove gs)
+                                                       (gsCoord gs) }
+logicFun gs (KeyPress c)  = Right $ gs { gsMove = move (gsMove gs) c }
+
 -- SCI movement
 move :: Move -> Char -> Move
 move N 'w' = Stop
@@ -47,22 +53,36 @@
 move _ 'd' = E
 move m _   = m
 
--- todo add boundaries
-pos :: Move -> (Integer, Integer) -> (Integer, Integer)
-pos Stop cs = cs
-pos N    (r, c) = (r-1, c  )
-pos S    (r, c) = (r+1, c  )
-pos E    (r, c) = (r  , c+1)
-pos W    (r, c) = (r  , c-1)
+pos :: Move -> (Width, Height) -> (Width, Height)
+pos m oldcs | oob newcs = oldcs
+            | otherwise = newcs
+    where
+          newcs = new m oldcs
 
+          new Stop cs = cs
+          new N    (r, c) = (r-1, c  )
+          new S    (r, c) = (r+1, c  )
+          new E    (r, c) = (r  , c+1)
+          new W    (r, c) = (r  , c-1)
 
--- DRAW --
+          ((lr, lc), (hr, hc)) = boundaries
+          oob (r, c) = r <= lr || c <= lc ||
+                       r >= hr || c >= hc
 
-drawFun :: GameState -> Plane
-drawFun (GameState (r, c) _ _) =
-                           blankPlane 80 25 &
-                (1, 1)   % box '_' 80 25    &
-                (2, 2)   % box ' ' 78 23    &
-                (15, 20) % textBox "tap WASD to move, tap again to stop"
-                                   10 4     &
-                (r, c) % cell '@'
+-------------------------------------------------------------------------------
+-- Draw
+
+drawFun :: MyState -> Plane
+drawFun (MyState (r, c) _) =
+                           blankPlane mw     mh            &
+                (1, 1)   % box mw mh '.'                   &
+                (2, 2)   % box (mw-2) (mh-2) ' '           &
+                (15, 20) % textBox 10 4
+                                   "Tap WASD to move, tap again to stop." &
+                (20, 60) % textBox 8 10
+                                   "Press Q to quit." # color Blue Vivid &
+                (r, c) % cell '@' # invert
+    where
+          mh :: Height
+          mw :: Width
+          (mh, mw) = snd boundaries
diff --git a/example/Balls.hs b/example/Balls.hs
new file mode 100644
--- /dev/null
+++ b/example/Balls.hs
@@ -0,0 +1,188 @@
+module Balls where
+
+-- library module for `balls`
+
+import Terminal.Game
+
+import qualified Data.Bool as B
+import qualified Data.Ix as I
+import qualified Data.Maybe as M
+import qualified Data.Tuple as T
+
+{-
+   There are three things I will showcase in this example:
+
+   1. ** How you can display current FPS. **
+      This is done using information passed via `GEnv` (eFPS).
+
+   2. ** How your game can gracefully handle screen resize. **
+      Notice how if you resize the terminal, balls will still
+      fill the entire screen. This is again possible using `Game`
+      and the information passed via GEnv (in this case, terminal
+      dimensions).
+
+   3. ** That — while FPS can change  — game speed does not. **
+      Check the timer: even when screen is crowded and frames are
+      dropped, it is not slowed down.
+
+
+   This game runs at 60 FPS, you will almost surely never need such
+   a high TPS! 15–20 is more than enough in most cases.
+-}
+
+-------------------------------------------------------------------------------
+-- Ball
+
+data Ball = Ball { pChar :: Plane,
+                   pSpeed :: Timed Bool,
+                   pDir :: Coords,
+                   pPos :: Coords }
+
+-- change direction is necessary, then and move
+modPar :: Dimensions -> Ball -> Maybe Ball
+modPar ds b@(Ball _ _ d _) =
+            -- tick the ball and check it is time to move
+            let b' = tickBall b in
+            if not (fetchFrame . pSpeed $ b')
+              then Just b' -- no time to move for you
+            else
+
+            -- check all popssible directions
+            let pd = [d, togR d, togC d, togB d]
+                bs  = map (\ld -> b' { pDir = ld })  pd
+                bs' = filter (isIn ds) $ map modPos bs in
+
+            -- returns a moved ball nor nothing to mark it “to eliminate”
+            case bs' of
+              [] -> Nothing
+              (cp:_) -> Just cp
+    where
+          togR (wr, wc) = (-wr,  wc)
+          togC (wr, wc) = ( wr, -wc)
+          togB (wr, wc) = (-wr, -wc)
+
+tickBall :: Ball -> Ball
+tickBall b = b { pSpeed = tick (pSpeed b) }
+
+modPos :: Ball -> Ball
+modPos (Ball p t d@(dr, dc) (r, c)) = Ball p t d (r+dr, c+dc)
+
+isIn :: Dimensions -> Ball -> Bool
+isIn (w, h) (Ball p _ _ (pr, pc)) =
+            let (pw, ph) = planeSize p
+            in pr >= 1 &&
+               pr+ph-1 <= h &&
+               pc >= 1 &&
+               pc+pw-1 <= w
+
+dpart :: Ball -> (Coords, Plane)
+dpart (Ball p _ _ cs) = (cs, p)
+
+genBall :: StdGen -> Dimensions -> (Ball, StdGen)
+genBall g ds =
+                let (c, g1) = pickRandom [minBound..] g
+                    (s, g2) = getRandom (1, 3) g1
+                    (v, g3) = pickRandom dirs g2
+                    (p, g4) = ranIx ((1,1), T.swap ds) g3
+                    b = Ball (cell 'o' # color c Vivid)
+                             (creaBoolTimerLoop s) v p
+                in (b, g4)
+        where
+              dirs = [(1, 1), (1, -1), (-1, 1), (-1, -1)]
+
+              -- tuples instances are yet to be added to `random`
+              -- as nov 21; this will do meanwhile.
+              ranIx :: I.Ix a => (a, a) -> StdGen -> (a, StdGen)
+              ranIx r wg = pickRandom (I.range r) wg
+
+-------------------------------------------------------------------------------
+-- Timer
+
+type Timer = (Timed Bool, Integer)
+
+ctimer :: TPS -> Timer
+ctimer tps = (creaBoolTimerLoop tps, 0)
+
+ltimer :: Timer -> Timer
+ltimer (t, i) = let t' = tick t
+                    k = B.bool 0 1 (fetchFrame t')
+                in (t', i+k)
+
+dtimer :: Timer -> Plane
+dtimer (_, i) = word . show $ i
+
+-------------------------------------------------------------------------------
+-- Game
+
+data GState = GState { gen :: StdGen,
+                       timer :: Timer,
+                       balls :: [Ball],
+                       bslow :: Bool }
+            -- pSlow is not used in game, it is there just
+            -- for the test suite
+
+fireworks :: StdGen -> Game GState Int
+fireworks g = Game tps istate lfun dfun
+    where
+          tps = 60
+
+          istate :: GState
+          istate = GState g (ctimer tps) [] False
+
+-------------------------------------------------------------------------------
+-- Logic
+
+-- The `Int` in `Either Int Gstate` is: number of balls
+-- on screen at the end of the game.
+lfun :: GEnv -> GState -> Event -> Either Int GState
+lfun e s (KeyPress 's') =
+            let g = gen s
+                ds = eTermDims e
+                (b, g1) = genBall g ds
+                s' = s { gen = g1,
+                         balls = b : balls s }
+            in Right s'
+lfun _ s (KeyPress 'q') = Left $ length (balls s)
+lfun _ s (KeyPress _)   = Right s
+lfun r s Tick           =
+            let ds = eTermDims r
+
+                ps = balls s
+                ps' = M.mapMaybe (modPar ds) ps
+
+                bs = eFPS r < 30
+                s' = s { timer = ltimer (timer s),
+                         balls = filter (isIn ds)  ps',
+                         bslow = bs }
+            in Right s'
+
+-------------------------------------------------------------------------------
+-- Draw
+
+dfun :: GEnv -> GState -> Plane
+dfun r s =             mergePlanes
+                         (uncurry blankPlane ds)
+                         (map dpart $ balls s) &
+            (1, 2) %^> tui # trans &
+            (1, 2) %.< inst # trans # bold
+    where
+          ds = eTermDims r
+          tm = timer s
+
+          tui :: Plane
+          tui = let fps = eFPS r
+                    np = length $ balls s
+
+                    l1 = word "FPS: " ||| word (show fps)
+                    l2 = word "Timer: " ||| dtimer tm
+                    l3 = word ("Balls: " ++ show np)
+                    l4 = word ("Term. dims.: " ++ show ds)
+                in vcat [l1, l2, l3, l4]
+
+          inst :: Plane
+          inst = word "Press (s) to spawn" ===
+                 word "Press (q) to quit"  ===
+                 word "Resize terminal to pop balls"
+
+          trans :: Draw
+          trans = makeTransparent ' '
diff --git a/example/MainAlone.hs b/example/MainAlone.hs
new file mode 100644
--- /dev/null
+++ b/example/MainAlone.hs
@@ -0,0 +1,12 @@
+module Main where
+
+
+import Alone ( aloneInARoom, sizeCheck )
+
+import Terminal.Game
+
+-- run with: cabal new-run -f examples alone
+
+main :: IO ()
+main = do sizeCheck
+          errorPress $ playGame aloneInARoom
diff --git a/example/MainBalls.hs b/example/MainBalls.hs
new file mode 100644
--- /dev/null
+++ b/example/MainBalls.hs
@@ -0,0 +1,22 @@
+module Main where
+
+import Balls
+
+import Terminal.Game
+
+-- Balls Main module. The meat of the game is in `examples/Balls.hs`
+
+main :: IO ()
+main = do
+        g <- getStdGen
+        r <- playGame (fireworks g)
+            -- We use game result `r` (how many balls were on
+            -- screen) and feed it to another function.
+            -- This could be useful to upload high scores to
+            -- a site, or for a game embedded in a larger pro-
+            -- gram, etc.
+        putStrLn (bye r)
+    where
+          bye wi = "See you later!\nYou left the game with " ++
+                   show wi ++ " balls on screen."
+
diff --git a/example/MainHotReload.hs b/example/MainHotReload.hs
new file mode 100644
--- /dev/null
+++ b/example/MainHotReload.hs
@@ -0,0 +1,87 @@
+module Main where
+
+import Alone ( aloneInARoom, sizeCheck )
+
+import Terminal.Game
+
+-- Hot reloading is a handy feature while writing a game. Here I will
+-- show you various ways to do that with ansi-terminal-game.
+--
+-- Hot reloading makes use of `entr` (install it from your repos) and
+-- some additional scaffolding, provided by `tmux` or your plain terminal.
+-- Read below to see two ideas in action.
+
+
+{- === HOT RELOAD WITH ENTR AND TMUX ===
+
+	1. Install `entr` and `tmux`.
+
+    2. open a tmux window, in the bottom-right plane launch the game
+       in an infinite loop, e.g.
+
+         while true; do cabal run -f examples alone; done
+
+       Remember, the pane has to be the bottom-right one, like this:
+
+            +----------------------------------------------+
+            |                        |                     |
+            |                        |                     |
+            |                        |                     |
+            |                        |                     |
+            |                        |                     |
+            |                        |                     |
+            |                        |---------------------|
+            |                        |                     |
+            |                        |                     |
+            |                        |                     |
+            |                        |       G A M E       |
+            |                        |                     |
+            |                        |                     |
+            |                        |                     |
+            +----------------------------------------------+
+
+     3. in another pane launch `entr` in this fashion:
+
+          find src example/ -name *.hs | entr tmux send-keys -t {bottom-right} q
+
+     4. Now whenever you modify a source file in example/ , the game
+        will be reloaded!  -}
+
+
+{- === HOT RELOAD WITH ENTR AND PLAIN TERMINAL ===
+
+    1. If your terminal has a `command` option, it is even easier.
+       We will use `urxvt` for this example
+
+          find src example/*.hs | entr -r urxvt -e cabal run -f examples alone
+
+    2. Every time you save a source file, a terminal will be spawn with
+       your game running in it.  -}
+
+
+{-  === HOT RELOAD REPLAYS WITH ENTR ===
+
+    `entr` by itself *cannot* autoreload a game in the same window, as it
+    cannot handle interactive programs. But if you are just displaying a
+    replay, this can come handy
+
+        find example/*.hs | entr -cr cabal run -f examples hot-reload
+
+    This is very useful to incrementally build NPCs’ behaviour,
+    iron out mechanics bugs etc.
+
+    Remember that you can use `recordGame` to record a session.  -}
+
+
+-- If you you need something fancier for your game (e.g. hot reloading user
+-- maps), `venzone` [1] (module Watcher) has a builtin /watch mode/ you can
+-- take inspiration from.
+--
+-- [1] https://hackage.haskell.org/package/venzone
+
+main :: IO ()
+main = do
+        sizeCheck
+        gr <- readRecord "test/records/alone-record-test.gr"
+                -- check `readRecord
+        () <$ narrateGame aloneInARoom gr
diff --git a/example/MainPlayback.hs b/example/MainPlayback.hs
new file mode 100644
--- /dev/null
+++ b/example/MainPlayback.hs
@@ -0,0 +1,30 @@
+module Main where
+
+import Alone ( aloneInARoom, sizeCheck )
+
+import Terminal.Game
+
+import System.IO.Temp ( emptySystemTempFile )
+
+-- plays the game and, once you quit, shows a replay of the session
+-- run with: cabal new-run -f examples alone-playback
+
+main :: IO ()
+main = do
+        sizeCheck
+        tf <- emptySystemTempFile "alone-record.gr"
+        playback tf
+
+playback :: FilePath -> IO ()
+playback f = do
+        prompt "Press <Enter> to play the game."
+        recordGame aloneInARoom f
+        prompt "Press <Enter> to watch playback."
+        es <- readRecord f
+        _ <- narrateGame aloneInARoom es
+        prompt "Playback over! Press <Enter> to quit."
+    where
+          prompt :: String -> IO ()
+          prompt s = putStrLn s >> () <$ getLine
+
+
diff --git a/platform-dep/non-win/Terminal/Game/Input.hs b/platform-dep/non-win/Terminal/Game/Input.hs
deleted file mode 100644
--- a/platform-dep/non-win/Terminal/Game/Input.hs
+++ /dev/null
@@ -1,9 +0,0 @@
---------------------------------------------------------------------------------
--- Nonbuffering getChar
--- 2017 Francesco Ariis GPLv3                                             80cols
---------------------------------------------------------------------------------
-
-module Terminal.Game.Input where
-
-inputCharTerminal :: IO Char
-inputCharTerminal = getChar
diff --git a/platform-dep/non-win/Terminal/Game/Utils.hs b/platform-dep/non-win/Terminal/Game/Utils.hs
new file mode 100644
--- /dev/null
+++ b/platform-dep/non-win/Terminal/Game/Utils.hs
@@ -0,0 +1,14 @@
+--------------------------------------------------------------------------------
+-- Nonbuffering getChar
+-- 2017 Francesco Ariis GPLv3                                             80cols
+--------------------------------------------------------------------------------
+
+module Terminal.Game.Utils ( inputCharTerminal,
+                             isWin32Console )
+                           where
+
+inputCharTerminal :: IO Char
+inputCharTerminal = getChar
+
+isWin32Console :: IO Bool
+isWin32Console = return False
diff --git a/platform-dep/windows/Terminal/Game/Input.hs b/platform-dep/windows/Terminal/Game/Input.hs
deleted file mode 100644
--- a/platform-dep/windows/Terminal/Game/Input.hs
+++ /dev/null
@@ -1,22 +0,0 @@
---------------------------------------------------------------------------------
--- Nonbuffering getChar
--- 2017 Francesco Ariis GPLv3                                             80cols
---------------------------------------------------------------------------------
-{-# LANGUAGE ForeignFunctionInterface #-}
-
--- see .cabal conditionals for more info
-
-module Terminal.Game.Input where
-
-import qualified Foreign.C.Types as FT
-import qualified Data.Char       as C
-
-inputCharTerminal :: IO Char
-inputCharTerminal = getCharWindows
-
--- no idea but unsafe breaks it
-getCharWindows :: IO Char
-getCharWindows = fmap (C.chr . fromEnum) c_getch
-foreign import ccall safe "conio.h getch"
-  c_getch :: IO FT.CInt
-
diff --git a/platform-dep/windows/Terminal/Game/Utils.hs b/platform-dep/windows/Terminal/Game/Utils.hs
new file mode 100644
--- /dev/null
+++ b/platform-dep/windows/Terminal/Game/Utils.hs
@@ -0,0 +1,30 @@
+--------------------------------------------------------------------------------
+-- Nonbuffering getChar et al
+-- 2017 Francesco Ariis GPLv3                                             80cols
+--------------------------------------------------------------------------------
+{-# LANGUAGE ForeignFunctionInterface #-}
+
+-- horrible horrible horrible hack to make unbuffered input
+-- work on Windows (and win32console check)
+
+module Terminal.Game.Utils (inputCharTerminal,
+                            isWin32Console )
+                           where
+
+import qualified Data.Char             as C
+import qualified Foreign.C.Types       as FT
+import qualified System.Console.MinTTY as M
+
+inputCharTerminal :: IO Char
+inputCharTerminal = getCharWindows
+
+-- no idea why, but unsafe breaks it
+getCharWindows :: IO Char
+getCharWindows = fmap (C.chr . fromEnum) c_getch
+foreign import ccall safe "conio.h getch"
+  c_getch :: IO FT.CInt
+
+-- TODO elimina isWin32Console [win]
+-- not perfect, but it is what it is (on win, non minTTY)
+isWin32Console :: IO Bool
+isWin32Console = not <$> M.isMinTTY
diff --git a/src/Terminal/Game.hs b/src/Terminal/Game.hs
--- a/src/Terminal/Game.hs
+++ b/src/Terminal/Game.hs
@@ -1,8 +1,8 @@
---------------------------------------------------------------------------------
+-------------------------------------------------------------------------------
 -- |
 -- Module      :  Terminal.Game
--- Copyright   :  © 2017-2018 Francesco Ariis
--- License     :  GPLv3 (see LICENSE file)
+-- Copyright   :  © 2017-2023 Francesco Ariis et al.
+-- License     :  GPLv3 (see COPYING)
 --
 -- Maintainer  :  Francesco Ariis <fa-ml@ariis.it>
 -- Stability   :  provisional
@@ -10,70 +10,246 @@
 --
 -- Machinery and utilities for 2D terminal games.
 --
---------------------------------------------------------------------------------
+-- New? Start from 'Game'.
+--
+-------------------------------------------------------------------------------
 
 -- Basic col-on-black ASCII terminal, operations.
 -- Only module to be imported.
 
--- todo color [release]
--- todo resize screen corruption [grave]
--- add docs [release]
+-- todo you can eliminate unidecode!
+-- todo you probably can eliminate part of platform dep too (ffi)
+--      (anche check what is linked -- see lib.so.8 error)
+-- todo you should check again on win the «press exit to continue» test
+-- todo write that ascii/latin-1/greek letters should be ok on win
 
-module Terminal.Game ( -- * Game Loop
-                       gameLoop,
-                       -- * Plane
-                       Plane,                  -- types
-                       Coords, Width, Height,
-                       stringPlane,            -- crea
-                       blankPlane, addVitrum,
-                       copyPlane, pastePlane,  -- slice
-                       planeSize, paperPlane,  -- info
-                       -- * Draw
-                       (%), (&), cell,         -- draw
-                       box, textBox,
-                       -- * Animations
-                       Animation, Loop(..),    -- types
-                       creaAni,
-                       tick, reset,            -- operate
-                                             -- xxx metti fetchframe in
-                                             --     documentation
-                                             --     e anche isexpired
-                       getFrames,
-                       encodeAni,              -- serialise
-                       decodeAni,
-                       -- * Timers
-                       Timed,                  -- types
-                       ExpBehaviour(..),
-                       creaTimer,              -- crea
-                       creaBoolTimer,
-                       fetchFrame, isExpired,  -- operate
-                       -- * Utils
-                       screenSize
+-- todo rewrite test w/ an internal library method
+
+module Terminal.Game ( -- * Running
+                       TPS,
+                       FPS,
+                       Event(..),
+                       GEnv(..),
+                       Game(..),
+                       playGame,
+                       ATGException(..),
+
+                       -- ** Helpers
+                       playGame_,
+                       Terminal.Game.displaySize,
+                       assertTermDims,
+                       errorPress,
+                       blankPlaneFull,
+                       centerFull,
+
+                       -- * Game logic
+                       -- | Some convenient function dealing with
+                       -- Timers ('Timed') and 'Animation's.
+                       --
+                       -- Usage of these is not mandatory: 'Game' is
+                       -- parametrised over any state @s@, you are free
+                       -- to implement game logic as you prefer.
+
+                       -- ** Timers/Animations
+
+                       -- *** Timers
+                       Timed,
+                       creaTimer, creaBoolTimer,
+                       creaTimerLoop, creaBoolTimerLoop,
+
+                       -- *** Animations
+                       Animation,
+                       creaAnimation,
+                       creaLoopAnimation,
+
+                       -- *** T/A interface
+                       tick, ticks, reset, lapse,
+                       fetchFrame, isExpired,
+
+                       -- ** Random numbers
+                       StdGen,
+                       getStdGen, mkStdGen,
+                       getRandom, pickRandom,
+                       UniformRange,
+
+                       -- * Drawing
+                       -- | To get to the gist of drawing, check the
+                       -- documentation for '%'.
+                       --
+                       -- Blitting on screen is double-buffered and diff'd
+                       -- (at each frame, only cells with changed character
+                       -- will be redrawn).
+
+                       -- ** Plane
+                       Plane,
+                       Dimensions,
+                       Coords,
+                       Row, Column,
+                       Width, Height,
+                       blankPlane,
+                       stringPlane,
+                       stringPlaneTrans,
+                       makeTransparent,
+                       makeOpaque,
+                       planePaper,
+                       planeSize,
+
+                       -- *** Performance blitting
+                       -- $performance
+
+                       Cell,
+                       creaCell,
+                       colorCell,
+                       rgbColorCell,
+                       paletteColorCell,
+                       boldCell,
+                       reverseCell,
+                       cellsPlane,
+
+                       -- ** Draw
+                       Draw,
+                       (%), (&), (#),
+                       subPlane,
+                       mergePlanes,
+                       cell, word, box,
+                       Color(..), ColorIntensity(..),
+                       color, bold, invert,
+
+                       -- *** Alternative origins
+                       -- $origins
+                       (%^>), (%.<), (%.>),
+
+                       -- *** Text boxes
+                       textBox, textBoxLiquid,
+                       textBoxHyphen, textBoxHyphenLiquid,
+                       Hyphenator,
+                       -- | Eurocentric convenience reexports. Check
+                       -- "Text.Hyphenation.Language" for more languages.
+                       english_GB, english_US, esperanto,
+                       french, german_1996, italian, spanish,
+
+                       -- *** Declarative drawing
+                       (|||), (===), (***), hcat, vcat,
+
+                       -- *** Non-standard colors
+                       -- | Non-standard RGB and xterm colors. These are
+                       -- prettier, but work on a minority of terminal
+                       -- emulators/multiplexers.
+                       -- Use them only on your machine or when you are sure
+                       -- of the terminal you are targetting.
+                       S.Colour, rgbColor, paletteColor,
+                       S.sRGB24, S.sRGBBounded, S.sRGB, S.sRGB24read,
+                       xterm6LevelRGB, xterm24LevelGray, xtermSystem,
+
+                       -- * Testing
+                       GRec,
+                       recordGame,
+                       readRecord,
+                       testGame,
+                       setupGame,
+                       narrateGame,
+
+                       -- | A quick and dirty way to have /hot reload/
+                       -- (autorestarting your game when source files change)
+                       -- is illustrated in @example/MainHotReload.hs@.
+
+                       -- * Embedding files
+
+                       -- | Embedding files is convenient when working on
+                       -- assets separately and still wanting to ship a
+                       -- single binary. Remember to add this pragma to
+                       -- the top of your module:
+                       --
+                       -- > {-# LANGUAGE TemplateHaskell #-}
+                       embedFile,
+                       embedDir,
+                       BC.ByteString,
+                       BC.unpack,
+
+                       -- * Cross platform
+                       -- $xcompat
                      )
     where
 
-import Terminal.Game.GameLoop
-import Terminal.Game.Plane
-import Terminal.Game.Draw
--- xxx rivedi gli export di animation, encapsula tutto il possibile
+import Data.FileEmbed
+import System.Console.ANSI
 import Terminal.Game.Animation
-import Terminal.Game.Timer
-import Terminal.Game.Utils
+import Terminal.Game.Draw
+import Terminal.Game.Layer.Imperative
+import Terminal.Game.Layer.Object as O
+import Terminal.Game.Plane
+import Terminal.Game.Random
+import Text.LineBreak
 
--- todo text deve essere gestito da una cosa smart, pensa a pp leijin
+import qualified Control.Monad as CM
+import qualified Data.ByteString.Char8 as BC
+import qualified Data.Colour.SRGB as S
 
--- todo [post-first-release] setTitle hSupportsANSI bold? italics? intensity
+-- $origins
+-- Placing a plane is sometimes more convenient if the coordinates origin
+-- is a corner other than top-left (e.g. “Paste this plane one row from
+-- bottom-left corner”). These combinators — meant to be used instead of '%'
+-- — allow you to do so. Example:
+--
+-- @
+-- prova :: Plane
+-- prova = let rect = box 6 3  \'.\'
+--             letters = word "ab"
+--         in            rect &
+--            (1, 1) %.> letters         -- start from bottom-right
+--
+--     -- λ> putStr (planePaper prova)
+--     -- ......
+--     -- ......
+--     -- ....ab
+-- @
 
--- todo geekosaur threaded shit bug
+-- $xcompat
+-- Good practices for cross-compatibility:
+--
+-- * Choose game dimensions of no more than __24 rows__ and __80 columns__.
+--   This ensures compatibility with the trickiest terminals (i.e. Win32
+--   console).
+--
+-- * Use __ASCII characters__ only. Again this is for Win32 console
+--   compatibility, until
+--   [this GHC bug](https://gitlab.haskell.org/ghc/ghc/issues/7593) gets
+--   fixed.
+--
+-- * Employ colour sparingly: as some users will play your game in a
+--   light-background terminal and some in a dark one, choose only colours
+--   that go well with either (blue, red, etc.).
+--
+-- * Some terminals/multiplexers (i.e. tmux) do not make a distinction
+--   between vivid/dull, others do not display bold; do not base your game
+--   mechanics on that difference.
+--
+-- * If you use WASD for movement, you can readily gain compatibility with
+--   AZERTY keyboard layout by mapping “up” to both @W@ and @Z@ and “left”
+--   to @A@ and @Q@. Users from France, Belgium, and Québec will thank you.
 
---    geekosaur f-a, a. heh. so the thoguht I had turned out to
---           be correct:
---           Control.Concurent.rtsSupportsBoundThreads (because
---           green threads can't be usefully bound)
---            x hiratara
---              [~hiratara@240f:7:4708:1:47a:b8c4:d18a:d063]
---              has left Ping timeout: 276 seconds [#haskell]
---    geekosaur so if that produces True, it's using the
---              threaded runtime; if False, you can say
---              something useful instead of hanging
+-- $performance
+-- Using 'Plane' for graphics is convenient due to the many primitives
+-- for drawing.  If you need extra performance, @ansi-terminal-game@
+-- exposes 'Cell' functions too, for efficient dense-grid drawing.
+--
+-- Remember that most likely the bottleneck for your app will still be
+-- the terminal your users run!
 
+-- | /Usable/ terminal display size (on Win32 console the last line is
+-- set aside for input). Throws 'CannotGetDisplaySize' on error.
+displaySize :: IO Dimensions
+displaySize = O.displaySizeErr
+
+-- | Check if terminal can accomodate 'Dimensions', otherwise throws
+-- 'DisplayTooSmall' with a helpful message for the player.
+assertTermDims :: Width -> Height -> IO ()
+assertTermDims dw dh =
+            clearScreen >>
+            setCursorPosition 0 0 >>
+            displaySizeErr >>= \ads ->
+            CM.when (isSmaller ads)
+                    (throwExc $ DisplayTooSmall (dw, dh) ads)
+    where
+          isSmaller :: Dimensions -> Bool
+          isSmaller (ww, wh) = ww < dw || wh < dh
diff --git a/src/Terminal/Game/ANSI.hs b/src/Terminal/Game/ANSI.hs
deleted file mode 100644
--- a/src/Terminal/Game/ANSI.hs
+++ /dev/null
@@ -1,96 +0,0 @@
--------------------------------------------------------------------------------
--- ANSI terminal display
--- (C) 2017 Francesco Ariis (GPL v3)
--------------------------------------------------------------------------------
-
--- Plane to ANSI terminal display
-
-module Terminal.Game.ANSI where
-
-import Terminal.Game.Draw
-import Terminal.Game.Plane
-
-import qualified System.Console.ANSI as CA
-import qualified Data.List.Split as LS
-import qualified Control.Monad as CM
-import qualified Data.Array as A
-
--- xxx elmina 80 cols
-
--- th tw: terminal width and height
--- pn: new plane, po: old plane
--- fps sono gli fps attuali, puoi stamparli come preferisci (o non stamparli)
--- wo, ho: dimensions of the terminal. If they change, reinit double buffering
-blitPlane :: Width -> Height -> Maybe Plane -> Plane -> Integer -> IO ()
-blitPlane tw th mpo pn cFps =
-
-        -- old plane
-        let
-            (pw, ph) = planeSize pn
-            bp  = blankPlane pw ph
-            po  = pastePlane (maybe bp id mpo) bp (1, 1)
-        in
-
-        -- new plane
-        let pn'  = pastePlane pn bp (1, 1)
-            pn'' = pastePlane (textBox (show cFps) 100 100) pn' (1, 2)
-        in
-
-        -- reset formatting and print everything
-        -- CA.setSGR [CA.Reset, CA.SetColor CA.Background CA.Dull CA.Black] >>
-        CA.setSGR [CA.Reset] >>
-        blitMap po pn' tw th
-
-
------------------
--- ANCILLARIES --
------------------
-
--- plane + term w/h
-blitMap :: Plane -> Plane -> Width -> Height -> IO ()
-blitMap po pn tw th = CM.when (planeSize po /= planeSize pn)
-                              (error "blitMap: different plane sizes")      >>
-                      CA.setCursorPosition (fi cr) (fi cc)                  >>
-                      blitToTerminal cc (orderedCells po) (orderedCells pn)
-    where
-          (pw, ph) = planeSize pn
-
-          cr = div (th - ph) 2
-          cc = div (tw - pw) 2
-
-          fi = fromIntegral
-
-orderedCells :: Plane -> [[Cell]]
-orderedCells p = LS.chunksOf (fromIntegral w) cells
-    where
-          -- todo altra funzione invece che un map 2nd?
-          cells  = map snd $ assocsPlane p
-          (w, _) = planeSize p
-
-
--- ordered sequence of cells, both old and new, like they were a String to
--- print to screen
-blitToTerminal :: Column -> [[Cell]] -> [[Cell]] -> IO ()
-blitToTerminal rc ocs ncs = mapM_ blitLine oldNew
-    where
-          oldNew :: [[(Cell, Cell)]]
-          oldNew = zipWith zip ocs ncs
-
-          blitLine :: [(Cell, Cell)] -> IO ()
-          blitLine ccs = CM.foldM blitChar 0 ccs              >>
-                         CA.cursorDown 1                      >>
-                         CA.setCursorColumn (fromIntegral rc)
-
-          -- k is "spaces to skip"
-          blitChar :: Int -> (Cell, Cell) -> IO Int
-          blitChar k (clo, cln)
-                | cln == clo = return (k+1)
-                | otherwise  = moveIf k               >>= \k' ->
-                               putChar (cellChar cln) >>
-                               return k'
-
-          moveIf :: Int -> IO Int
-          moveIf k | k == 0    = return k
-                   | otherwise = CA.cursorForward k >>
-                                 return 0
-
diff --git a/src/Terminal/Game/Animation.hs b/src/Terminal/Game/Animation.hs
--- a/src/Terminal/Game/Animation.hs
+++ b/src/Terminal/Game/Animation.hs
@@ -1,12 +1,13 @@
-{-# LANGUAGE DeriveGeneric #-}
-{-# LANGUAGE DefaultSignatures #-}
-{-# LANGUAGE StandaloneDeriving #-}
-{-# LANGUAGE FlexibleInstances #-}
 -------------------------------------------------------------------------------
 -- Animation
 -- 2018 Francesco Ariis GPLv3
 -------------------------------------------------------------------------------
 
+-- {-# LANGUAGE DeriveGeneric #-}
+-- {-# LANGUAGE DefaultSignatures #-}
+-- {-# LANGUAGE StandaloneDeriving #-}
+-- {-# LANGUAGE FlexibleInstances #-}
+
 module Terminal.Game.Animation (module Terminal.Game.Animation,
                                 module T
                                ) where
@@ -15,39 +16,18 @@
 
 import Control.Timer.Tick as T
 
-import Data.Serialize
-import GHC.Generics
-
-import qualified Data.ByteString as BS
-import qualified Data.Bifunctor as BF
+-- import Data.Serialize
 
--- todo missing: creaani, creaframe, fetchcurrframe, etc.
+-- import qualified Data.ByteString as BS
+-- import qualified Data.Bifunctor as BF
 
+-- | An @Animation@ is a series of timed time-separated 'Plane's.
 type Animation = T.Timed Plane
 
-creaAni :: Loop -> [(Integer, Plane)] -> Animation
-creaAni = creaTimedRes
-
--------------------
--- SERIALISATION --
--------------------
-
--- deriving instance Generic loc => Generic (Frame loc)
--- instance (Generic loc, Serialize loc) => Serialize (Frame loc Integer)
-
-instance Serialize ExpBehaviour
-instance Serialize Loop
-instance Serialize Cell
-instance Serialize Plane
-instance Serialize Animation
-
-encodeAni :: FilePath -> Animation -> IO ()
-encodeAni fp fs = BS.writeFile fp (encode fs)
-
-decodeAni :: FilePath -> IO (Either String Animation)
-decodeAni fp = fmap decode (BS.readFile fp) >>=
-                  return . BF.bimap err id
-    where
-          err se = fp ++ ": " ++ se
-
+-- | Creates an 'Animation'.
+creaAnimation :: [(Integer, Plane)] -> Animation
+creaAnimation ips = creaTimedRes (Times 1 Elapse) ips
 
+-- | Creates a looped 'Animation'.
+creaLoopAnimation :: [(Integer, Plane)] -> Animation
+creaLoopAnimation ips = creaTimedRes AlwaysLoop ips
diff --git a/src/Terminal/Game/Character.hs b/src/Terminal/Game/Character.hs
new file mode 100644
--- /dev/null
+++ b/src/Terminal/Game/Character.hs
@@ -0,0 +1,43 @@
+module Terminal.Game.Character where
+
+import Data.Char        as C
+import Text.Unidecode   as D
+import System.IO.Unsafe as U
+
+
+import Terminal.Game.Utils
+
+-- Non ASCII character still cause crashes on Win32 console (see this
+-- report: https://gitlab.haskell.org/ghc/ghc/issues/7593 ).
+-- We provide a function to substitute them when playing on Win32
+-- console, with another appropriate chatacter.
+
+win32SafeChar :: Char -> Char
+win32SafeChar c | areWeWin32 = toASCII c
+                | otherwise  = c
+    where
+          areWeWin32 :: Bool
+          areWeWin32 = unsafePerformIO isWin32Console
+
+-- ANCILLARIES --
+
+toASCII :: Char -> Char
+toASCII c | C.isAscii c         = c
+          | Just cm <- lu       = cm    -- hand-made substitution
+          | [cu] <- unidecode c = cu    -- unidecode
+          | otherwise           = '?'   -- all else failing
+    where
+          lu = lookup c subDictionary
+
+subDictionary :: [(Char, Char)]
+subDictionary = [ -- various open/close quotes
+                  ('«', '<'),
+                  ('»', '>'),
+                  ('“', '\''),
+                  ('”', '\''),
+                  ('‘', '\''),
+                  ('’', '\''),
+
+                  -- typographical marks
+                  ('—', '-') ]
+
diff --git a/src/Terminal/Game/Draw.hs b/src/Terminal/Game/Draw.hs
--- a/src/Terminal/Game/Draw.hs
+++ b/src/Terminal/Game/Draw.hs
@@ -7,67 +7,244 @@
 -- assumed to be opaque
 
 module Terminal.Game.Draw (module Terminal.Game.Draw,
-                           module DF) where
+                           (F.&)
+                          ) where
 
 import Terminal.Game.Plane
 
 import Text.LineBreak
 
-import Data.Function as DF ( (&) )
+import qualified Data.Colour.RGBSpace as S
+import qualified Data.Function as F ( (&) )
+import qualified Data.List as L
+import qualified Data.Word as W
+import qualified System.Console.ANSI as CA
 
+
 -----------
 -- TYPES --
 -----------
 
+-- | A drawing function, usually executed with the help of '%'.
 type Draw = Plane -> Plane
 
+
+-----------------
+-- COMBINATORS --
+-----------------
+
+-- | Pastes one 'Plane' onto another. To be used along with 'F.&'
+-- like this:
+--
+-- @
+--  d :: Plane
+--  d =          blankPlane 100 100  &
+--      (3, 4) % box '_' 3 5         &
+--      (a, b) % cell \'A\' '#' bold
+-- @
 (%) :: Coords -> Plane -> Draw
 cds % p1 = \p2 -> pastePlane p1 p2 cds
+infixl 4 %
 
-    -- most of the drawing is done with % and &, e.g.
-    --
-    -- let d :: Plane
-    --     d =          blankPlane (100, 100) &
-    --         (3, 4) % box '_' Yellow (3, 5) &
-    --         (a, b) % butCell '@' Red
-    --
+-- | Apply style to plane, e.g.
+--
+-- > cell 'w' # bold
+(#) :: Plane -> Draw -> Plane
+p # sf = sf p
+infixl 8 #
 
+-- | Shorthand for sequencing 'Plane's, e.g.
+--
+-- @
+--           firstPlane  &
+--  (3, 4) '%' secondPlane &
+--  (1, 9) '%' thirdPlane
+-- @
+--
+-- is equal to
+--
+-- @
+--  mergePlanes firstPlane [((3,4), secondPlane),
+--                          ((1,9), thirdPlane)]
+-- @
+mergePlanes :: Plane -> [(Coords, Plane)] -> Plane
+mergePlanes p cps = L.foldl' addPlane p cps
+    where
+          addPlane :: Plane -> (Coords, Plane) -> Plane
+          addPlane bp (cs, tp) = bp F.& cs % tp
+
+-- | Place two 'Plane's side-by-side, horizontally.
+(|||) :: Plane -> Plane -> Plane
+(|||) a b = let (wa, ha) = planeSize a
+                (wb, hb) = planeSize b
+            in mergePlanes (blankPlane (wa + wb) (max ha hb))
+                           [((1,1),    a),
+                            ((1,wa+1), b)]
+
+-- | Place two 'Plane's side-by-side, vertically.
+(===) :: Plane -> Plane -> Plane
+(===) a b = let (wa, ha) = planeSize a
+                (wb, hb) = planeSize b
+            in mergePlanes (blankPlane (max wa wb) (ha + hb))
+                           [((1,1),    a),
+                            ((ha+1,1), b)]
+
+-- | @a *** b@ blits @b@ in the centre of @a@.
+(***) :: Plane -> Plane -> Plane
+(***) a b = let (aw, ah) = planeSize a
+                (bw, bh) = planeSize b
+                r = quot (ah - bh) 2 + 1
+                c = quot (aw - bw) 2 + 1
+            in           a F.&
+                (r, c) % b
+
+
+-- | Place a list of 'Plane's side-by-side, horizontally. Returns a 1×1
+-- transparent plane on empty list.
+hcat :: [Plane] -> Plane
+hcat [] = blankPlane 1 1 # makeTransparent ' '
+hcat ps = L.foldl1' (|||) ps
+
+-- | Place a list of 'Plane's side-by-side, vertically. Returns a 1×1
+-- transparent plane on empty list.
+vcat :: [Plane] -> Plane
+vcat [] = blankPlane 1 1 # makeTransparent ' '
+vcat ps = L.foldl1' (===) ps
+
+infixl 6 |||, ===, ***
+
+
+------------
+-- STYLES --
+------------
+
+-- | Set foreground color.
+color :: CA.Color -> CA.ColorIntensity -> Plane -> Plane
+color c i p = mapPlane (colorCell c i) p
+
+-- | Apply bold style to 'Plane'.
+bold :: Plane -> Plane
+bold p = mapPlane boldCell p
+
+-- | Swap foreground and background colours of 'Plane'.
+invert :: Plane -> Plane
+invert p = mapPlane reverseCell p
+
+-- | Set RGB color
+rgbColor :: S.Colour Float -> Plane -> Plane
+rgbColor k p = mapPlane (rgbColorCell k) p
+
+-- | Set Palette color
+paletteColor :: W.Word8 -> Plane -> Plane
+paletteColor k p = mapPlane (paletteColorCell k) p
+
+
 -------------
 -- DRAWING --
 -------------
 
-box :: Char -> Width -> Height -> Plane
-box chr w h = seqCellsDim w h cells
+-- | A box of dimensions @w h@.
+box :: Width -> Height -> Char -> Plane
+box w h chr = seqCellsDim w h cells
     where
           cells = [((r, c), chr) | r <- [1..h], c <- [1..w]]
 
+-- | A 1×1 @Plane@.
 cell :: Char -> Plane
-cell ch = box ch 1 1
+cell ch = box 1 1 ch
 
+-- | @1xn@ 'Plane' with a word in it. If you need to import multiline
+-- ASCII art, check 'stringPlane' and 'stringPlaneTrans'.
+word :: String -> Plane
+word w = seqCellsDim (L.genericLength w) 1 cells
+    where
+          cells = zip (zip (repeat 1) [1..]) w
+
 -- opaque :: Plane -> Plane
 -- opaque p = pastePlane p (box ' ' White w h) (1, 1)
 --     where
 --           (w, h) = pSize p
 
--- assumes ' ' are transparent
-textBox :: String -> Width -> Height -> Plane
-textBox cs w h = transparent
+-- | A text-box. Assumes @' '@s are transparent.
+textBox :: Width -> Height -> String -> Plane
+textBox w h cs = frameTrans w h (textBoxLiquid w cs)
+
+-- | Like 'textBox', but tall enough to fit @String@.
+textBoxLiquid :: Width -> String -> Plane
+textBoxLiquid w cs = textBoxGeneralLiquid Nothing w cs
+
+-- | As 'textBox', but hypenated. Example:
+--
+-- @
+-- (normal textbox)                        (hyphenated textbox)
+-- Rimasi un po’ a meditare nel buio       Rimasi un po’ a meditare nel buio
+-- velato appena dal barlume azzurrino     velato appena dal barlume azzurrino
+-- del fornello a gas, su cui              del fornello a gas, su cui sobbol-
+-- sobbolliva quieta la pentola.           liva quieta la pentola.
+-- @
+--
+-- Notice how in the right box /sobbolliva/ is broken in two. This
+-- can be useful and aesthetically pleasing when textboxes are narrow.
+textBoxHyphen :: Hyphenator -> Width -> Height -> String -> Plane
+textBoxHyphen hp w h cs = frameTrans w h (textBoxHyphenLiquid hp w cs)
+
+-- | As 'textBoxLiquid', but hypenated.
+textBoxHyphenLiquid :: Hyphenator -> Width -> String -> Plane
+textBoxHyphenLiquid h w cs = textBoxGeneralLiquid (Just h) w cs
+
+textBoxGeneralLiquid :: Maybe Hyphenator -> Width -> String -> Plane
+textBoxGeneralLiquid mh w cs = transparent
     where
           -- hypenathion
-          hyp = Nothing -- Just english_GB
-          bf  = BreakFormat (fromIntegral w) 4 '-' hyp
-          hcs = breakStringLn bf (take (fromIntegral $ w*h) cs)
-          hl  = fromIntegral $ length hcs
+          bf  = BreakFormat (fromIntegral w) 4 '-' mh
+          hcs = breakStringLn bf cs
+          h   = L.genericLength hcs
 
           f :: [String] -> [(Coords, Char)]
           f css = concatMap (uncurry rf) (zip [1..] css)
-              where rf :: Integer -> String -> [(Coords, Char)]
+              where rf :: Int -> String -> [(Coords, Char)]
                     rf cr ln = zip (zip (repeat cr) [1..]) ln
 
           out         = seqCellsDim w h (f hcs)
-          transparent = addVitrum ' ' out
+          transparent = makeTransparent ' ' out
 
 
+----------------------------
+-- ADDITIONAL COMBINATORS --
+----------------------------
+
+-- Coords as if origin were @ bottom-right
+recipCoords :: Coords -> Plane -> Plane -> Coords
+recipCoords (r, c) p p1 =
+            let (pw, ph) = planeSize p
+                (p1w, p1h) = planeSize p1
+                r' = ph-p1h-r+2
+                c' = pw-p1w-c+2
+            in (r', c')
+
+-- | Pastes a plane onto another (origin: top-right).
+(%^>) :: Coords -> Plane -> Draw
+(r, c) %^> p1 = \p ->
+            let (_, c') = recipCoords (r, c) p p1
+            in p F.& (r, c') % p1
+
+-- | Pastes a plane onto another (origin: bottom-left).
+(%.<) :: Coords -> Plane -> Draw
+(r, c) %.< p1 = \p ->
+            let (r', _) = recipCoords (r, c) p p1
+            in p F.& (r', c) % p1
+
+-- | Pastes a plane onto another (origin: bottom-right).
+(%.>) :: Coords -> Plane -> Draw
+cs %.> p1 = \p ->
+            let (r', c') = recipCoords cs p p1
+            in p F.& (r', c') % p1
+
+infixl 4 %^>
+infixl 4 %.<
+infixl 4 %.>
+
+
 -----------------
 -- ANCILLARIES --
 -----------------
@@ -79,4 +256,9 @@
 seqCells p cells = updatePlane p (map f cells)
     where
           f (cds, chr) = (cds, creaCell chr)
+
+-- paste plane on a blank one, and make ' ' transparent
+frameTrans :: Width -> Height -> Plane -> Plane
+frameTrans w h p = let bt = makeTransparent ' ' (blankPlane w h)
+                   in bt F.& (1, 1) % p
 
diff --git a/src/Terminal/Game/GameLoop.hs b/src/Terminal/Game/GameLoop.hs
deleted file mode 100644
--- a/src/Terminal/Game/GameLoop.hs
+++ /dev/null
@@ -1,193 +0,0 @@
--------------------------------------------------------------------------------
--- Input/compute/output loop
--- 2017 Francesco Ariis GPLv3
--------------------------------------------------------------------------------
-
-{-# OPTIONS_GHC -fno-warn-type-defaults #-}
-
-module Terminal.Game.GameLoop where
-
-import Terminal.Game.Plane
-import Terminal.Game.Input
-import Terminal.Game.ANSI
-import Terminal.Game.Utils
-import Control.Concurrent
-
-import qualified System.IO as SI
-import qualified Control.Monad as CM
-import qualified System.Console.ANSI as CA
-import qualified System.Console.Terminal.Size as TS
-import qualified System.Clock as SC
-import qualified Control.Exception as E
-
--- todo [release] [study] no full IO for s, but a
---      jailed IO (provided by a datatype), both for I
---      and for O
-
--- todo elimina fps ora che li puoi fare on IO
-
--- | Entry point for the game, should be called in @main@. The two
--- most important functions are the one dealing with logic and the
--- blitting one. Check @alone-in-a-room@ (you can compiler it with
--- @cabal new-build -f examples@) to see a simple game in action.
-gameLoop :: String                       -- ^Terminal title.
-            -> s                         -- ^Initial state of the game.
-            -> (s -> Maybe Char -> IO s) -- ^Logic function.
-            -> (s -> Plane)              -- ^Draw function.
-            -> (s -> Bool)               -- ^\"Should I quit?" function.
-            -> Integer                   -- ^Framerate (in fps).
-            -> IO ()
-gameLoop t s lf df qf fps =
-
-            E.finally (initPart >> game)
-                      cleanAndExit -- this will be run regardless
-                                   -- of exception
-    where
-          initPart :: IO ()
-          initPart = -- init
-                     SI.hSetBuffering SI.stdout SI.NoBuffering >>
-                     SI.hSetBuffering SI.stdin  SI.NoBuffering >>
-                     SI.hSetEcho SI.stdin False                >>
-
-                     -- title and initial setup/checks
-                     CA.setTitle t >>
-                     CA.hideCursor >>
-                     blackScreen
-
-          game :: IO ()
-          game = -- mvars & fork
-                 newMVar 1                          >>= \frameCounter ->
-                 newMVar Nothing                    >>= \inputChar ->
-                 forkIO (inputAction inputChar)     >>
-                 forkIO (incTimer frameCounter fps) >>
-
-                 logicDraw inputChar frameCounter
-                           s lf df qf Nothing
-                           (initFPSCounter 20) (0,0)
-
-
-----------------
--- CONCURRENT --
-----------------
-
--- get action char
-inputAction :: MVar (Maybe Char) -> IO ()
-inputAction mc = -- vedi platform-dep/
-                 inputCharTerminal    >>= \c ->
-                 swapMVar mc (Just c) >>
-                 inputAction mc
-
--- modifica il timer
-incTimer :: MVar Integer -> Integer -> IO ()
-incTimer mi fps = modifyMVar_ mi (return . succ) >>
-                  threadDelay delayAmount        >>
-                  incTimer mi fps
-    where
-          delayAmount :: Int
-          delayAmount = fromIntegral $ div (10^6) fps
-
-
--- from http://www.loomsoft.net/resources/alltut/alltut_lesson5.htm
-logicDraw :: MVar (Maybe Char) -> MVar Integer -> s -> -- input, ticks, state
-             (s -> Maybe Char -> IO s)              -> -- logic function
-             (s -> Plane)                           -> -- draw function
-             (s -> Bool)                            -> -- quit? function
-             Maybe Plane                            -> -- last blitted screen
-             FPSCounter                             -> -- FPS counter
-             (Width, Height)                        -> -- Term Dimensions
-             IO ()
-logicDraw mc mi s lf df qf opln fc td =
-
-        -- not to hog CPU cycles
-        -- todo come mai 300 così alto? come influenza i timer?
-        threadDelay 300 >>
-
-        -- quit?
-        if qf s
-          then return ()
-        else
-
-        -- no tick from timer yet?
-        readMVar mi >>= \k ->
-        if k <= 0
-          then logicDraw mc mi s lf df qf opln fc td
-        else
-
-        -- do logic
-        readMVarNothing mc                       >>= \c  ->
-        modifyMVar mi (\a -> return (a-1, a-1))  >>= \k' ->
-        lf s c                                   >>= \s' ->
-
-        -- not enough logic done? Skip blitting
-        if  k' > 0
-          then logicDraw mc mi s' lf df qf opln fc td
-        else
-
-        -- clear screen if resolution change
-        screenSize           >>= \td'@(tw, th) ->
-        let resc = td /= td' in
-        CM.when resc blackScreen    >>
-
-        let opln' | resc = Nothing   -- res changed? restart double buffering
-                  | otherwise = opln
-            npln  = df s'
-            cFps  = getCurrFPS fc     in
-        blitPlane tw th opln' npln cFps  >>
-        tickCounter fc                   >>= \fc' ->
-        logicDraw mc mi s' lf df qf (Just npln) fc' td'
-
-
------------------
--- FPS COUNTER --
------------------
-
--- poll fps every x frames, current fps, stored time, current fps
-data FPSCounter = FPSCounter Integer Integer SC.TimeSpec Integer
-
--- poll utctime every x ticks
-initFPSCounter :: Integer -> FPSCounter
-initFPSCounter x = FPSCounter x 0 0 0
-
-tickCounter :: FPSCounter -> IO FPSCounter
-tickCounter (FPSCounter g e t1 cf)
-        | g > e  = return (FPSCounter g (e+1) t1 cf)
-        | g == e = SC.getTime SC.Monotonic             >>= \t2 ->
-                   let dtn = SC.toNanoSecs $ SC.diffTimeSpec t2 t1
-                       fr  = fi dtn / fi (g+1)
-                       fps = round $ fi (10^9) / fr in
-                       --- xxx no div
-                   return (FPSCounter g 0 t2 fps)
-        | otherwise = error "tickCounter: g < e"
-    where
-          fi = fromIntegral
-
-getCurrFPS :: FPSCounter -> Integer
-getCurrFPS (FPSCounter _ _ _ cFps) = cFps
-
------------------
--- ANCILLARIES --
------------------
-
--- todo [release] catch any exception in IO and execute this
-cleanAndExit :: IO ()
-cleanAndExit = CA.setSGR [CA.Reset]     >>
-               CA.clearScreen           >>
-               CA.setCursorPosition 0 0 >>
-               CA.showCursor
-
-readMVarNothing :: MVar (Maybe a) -> IO (Maybe a)
-readMVarNothing mvar = readMVar mvar                           >>= \ma ->
-                       CM.unless (null ma)
-                                 (() <$ swapMVar mvar Nothing) >>
-                       return ma
-
--- turn screen into black
-blackScreen :: IO ()
-blackScreen = CA.setCursorPosition 0 0 >>
-              -- CA.setSGR [CA.Reset,
-              --           CA.SetColor CA.Foreground CA.Dull CA.White,
-              --           CA.SetColor CA.Background CA.Dull CA.Black] >>
-                         -- è dull black che voglio?
-              screenSize >>= \(w, h) ->
-              CM.replicateM_ (fromIntegral $ w*h) (putChar ' ')
-
diff --git a/src/Terminal/Game/Layer/Imperative.hs b/src/Terminal/Game/Layer/Imperative.hs
new file mode 100644
--- /dev/null
+++ b/src/Terminal/Game/Layer/Imperative.hs
@@ -0,0 +1,298 @@
+-------------------------------------------------------------------------------
+-- Layer 1 (imperative), as per
+-- https://www.parsonsmatt.org/2018/03/22/three_layer_haskell_cake.html
+-- 2019 Francesco Ariis GPLv3
+-------------------------------------------------------------------------------
+
+{-# Language ScopedTypeVariables #-}
+
+module Terminal.Game.Layer.Imperative where
+
+import Terminal.Game.Draw
+import Terminal.Game.Layer.Object
+
+import qualified Control.Concurrent as CC
+import qualified Control.Exception as E
+import qualified Control.Monad as CM
+import qualified Data.Bool as B
+import qualified Data.Either as ET
+import qualified Data.List as D
+import qualified System.IO as SI
+
+import Terminal.Game.Plane
+
+-- | Game definition datatype, parametrised on:
+--
+-- * your gamestate @s@; and
+-- * a result when the game is finished @r@. Simple games do not need this,
+--   just fill @r@ with @()@.
+--
+-- The two most important elements are the function dealing with logic and
+-- the drawing one. Check @alone@ demo (@cabal run -f examples alone@) to
+-- see a basic game in action.
+data Game s r = Game {
+        gTPS           :: TPS,
+            -- ^ Game speed in ticks per second. You do not
+            -- need high values, since the 2D canvas is coarse
+            -- (e.g. 13 TPS is enough for action games).
+        gInitState     :: s,   -- ^ Initial state of the game.
+        gLogicFunction :: GEnv -> s -> Event -> Either r s,
+            -- ^ Logic function.  If `gLogicFunction` returns @Right s@
+            -- the game will continue with state @s@; if it returns @Left@
+            -- the game is over (quit condition).
+            --
+            -- Curious to see how @r@ can be useful? Check
+            -- @cabal run -f examples balls@ and
+            -- @example/MainBalls.hs@.
+        gDrawFunction  :: GEnv -> s -> Plane
+            -- ^ Draw function. Just want to blit your game
+            -- in the middle? Check 'centerFull'.
+    }
+
+-- | A blank plane as big as the terminal.
+blankPlaneFull :: GEnv -> Plane
+blankPlaneFull e = uncurry blankPlane (eTermDims e)
+
+-- | Blits plane in the middle of terminal.
+--
+-- @
+--   draw :: GEnv -> MyState -> Plane
+--   draw ev s =
+--       centerFull ev $
+--         ⁝
+-- @
+centerFull :: GEnv -> Plane -> Plane
+centerFull e p = blankPlaneFull e *** p
+
+-- | Entry point for the game execution, should be called in @main@.
+--
+-- You __must__ compile your programs with @-threaded@; if you do not do
+-- this the game will crash, at start-up. Just add:
+--
+-- @
+-- ghc-options:      -threaded
+-- @
+--
+-- in your @.cabal@ file and you will be fine!
+playGame :: Game s r -> IO r
+playGame g = either id (error "`Right` in playGame") <$>
+               runGIO (runGameGeneral g)
+
+-- | As 'playGame', but ignore the result @r@.
+playGame_ :: Game s r -> IO ()
+playGame_ g = () <$ playGame g
+
+-- | Tests a game in a /pure/ environment. Aims to accurately emulate 'GEnv'
+-- changes (screen size, FPS) too. Returns a result @r@ or a state @s@ in
+-- case the Event stream is exhausted before the game exits.
+--
+-- A useful trick is to call 'recordGame' and press /Ctrl-C/ while playing
+-- (instead of quitting properly). This way @testGame@ will return
+-- @Left s@, a state that you can then inspect.
+testGame :: Game s r -> GRec -> Either r s
+testGame g ts =
+        case runTest (runGameGeneral g) ts of
+            (Nothing, l) -> error $ "testGame, exception called: " ++
+                                    show l
+                -- it is fine to use error here since in the end
+                -- hspec can deal with it gracefully and we give
+                -- more infos on a failed test
+            (Just s, _) -> s
+
+-- | As 'testGame', but returns 'Game' instead of result/state.
+-- Useful to fast-forward (e.g.: skip menus) before invoking 'playGame'.
+setupGame :: Game s r -> GRec -> Game s r
+setupGame g ts = let s' = testGame g ts
+                 in case s' of
+                      -- If the game is already over, return a mock logic
+                      -- function which simply ends the game.
+                      Left r -> g { gLogicFunction = \_ _ _ -> Left r }
+                      Right s -> g { gInitState = s }
+
+-- | Similar to 'testGame', runs the game given a 'GRec'. Unlike
+-- 'testGame', the playthrough will be displayed on screen. Useful when a
+-- test fails and you want to see how.
+--
+-- See this in action with  @cabal run -f examples alone-playback@.
+--
+-- Notice that 'GEnv' will be provided at /run-time/, and not
+-- record-time; this can make emulation slightly inaccurate if — e.g. —
+-- you replay the game on a smaller terminal than the one you recorded
+-- the session on.
+narrateGame :: Game s r -> GRec -> IO ()
+narrateGame g e = () <$ runReplay (runGameGeneral g) e
+
+-- | Play as in 'playGame' and write the session (input stream, etc.) to
+-- @file@. Then you can use this with 'testGame' and 'narrateGame'. Session
+-- will be recorded even if an exception happens while playing.
+recordGame :: Game s r -> FilePath -> IO ()
+recordGame g fp =
+        E.bracket
+          (CC.newMVar igrec)
+          (\ve -> writeRec fp ve)
+          (\ve -> () <$ runRecord (runGameGeneral g) ve)
+
+data Config = Config { cMEvents :: CC.MVar [Event],
+                       cTPS     :: TPS }
+
+runGameGeneral :: forall s r m. MonadGameIO m =>
+                  Game s r -> m (Either r s)
+runGameGeneral (Game tps s lf df) =
+            -- init
+            setupDisplay    >>
+            startEvents tps >>= \(InputHandle ve ts) ->
+            displaySizeErr  >>= \ds ->
+
+            -- do it!
+            let c = Config ve tps in
+            cleanUpErr (game c ds)
+                            -- this under will be run regardless
+                       (stopEvents ts >>
+                        shutdownDisplay  )
+    where
+          game :: MonadGameIO m => Config -> Dimensions -> m (Either r s)
+          game c wds = gameLoop c (Right s) lf df
+                                Nothing wds
+                                (creaFPSCalc tps)
+
+-- | Wraps an @IO@ computation so that any 'ATGException' or 'error' gets
+-- displayed along with a @\<press any key to quit\>@ prompt.
+-- Some terminals shut-down immediately upon program end; adding
+-- @errorPress@ to 'playGame' makes it easier to beta-test games on those
+-- terminals.
+errorPress :: IO a -> IO a
+errorPress m = E.catches m [E.Handler errorDisplay,
+                            E.Handler atgDisplay]
+    where
+          errorDisplay :: E.ErrorCall -> IO a
+          errorDisplay (E.ErrorCallWithLocation cs l) = report $
+              putStrLn (cs ++ "\n\n")        >>
+              putStrLn "Stack trace info:\n" >>
+              putStrLn l
+
+          atgDisplay :: ATGException -> IO a
+          atgDisplay e = report $ print e
+
+          report :: IO () -> IO a
+          report wm =
+              putStrLn "ERROR REPORT\n"                >>
+              wm                                       >>
+              putStrLn "\n\n <Press any key to quit>"  >>
+              SI.hSetBuffering SI.stdin SI.NoBuffering >>
+              getChar                                  >>
+              errorWithoutStackTrace "errorPress"
+
+
+-----------
+-- LOGIC --
+-----------
+
+-- from http://www.loomsoft.net/resources/alltut/alltut_lesson6.htm
+gameLoop :: MonadGameIO m     =>
+            Config            ->  -- event source
+            Either r s        ->  -- state
+            (GEnv ->
+              s -> Event ->
+              Either r s)     ->  -- logic function
+            (GEnv ->
+             s -> Plane)      ->  -- draw function
+            Maybe Plane       ->  -- last blitted screen
+            Dimensions        ->  -- Term dimensions
+            FPSCalc           ->  -- calculate fps
+            m (Either r s)
+gameLoop c s lf df opln td fps =
+
+        -- Quit?
+        areEventsOver >>= \qb ->
+            -- We will quit in case input stream (events) is exhausted.
+            -- This might happen during test/narrate.
+        if ET.isLeft s || qb
+          then return s
+        else
+
+        -- Fetch events (if any).
+        -- This is safe as we checked for `areEventsOver` above.
+        pollEvents (cMEvents c) >>= \es ->
+
+        -- no events? skip everything
+        if null es
+          then sleepABit (cTPS c)               >>
+               gameLoop c s lf df opln td fps
+        else
+
+        displaySizeErr          >>= \td' ->
+
+        -- logic
+        let ge = GEnv td' (calcFPS fps)
+            (i, s') = stepsLogic s (lf ge) es in
+
+        -- no `Tick` events? You do not need to blit, just update state
+        if i == 0
+          then gameLoop c s' lf df opln td fps
+        else
+
+        -- FPS calc
+        let fps' = addFPS i fps in
+
+        -- clear screen if resolution changed
+        let resc = td /= td' in
+        CM.when resc clearDisplay >>
+
+        -- draw
+        let
+            opln' | resc = Nothing -- res changed? restart double buffering
+                  | otherwise = opln
+            npln = case s' of
+                    (Right rs) -> df ge rs
+                    (Left _) -> uncurry blankPlane td'
+                    -- In case the logic function came to an end
+                    -- (Left), just print a blank plane.
+        in
+
+        blitPlane opln' npln >>
+
+        gameLoop c s' lf df (Just npln) td' fps'
+
+-- Int = number of `Tick` events
+stepsLogic :: Either r s -> (s -> Event -> Either r s) -> [Event] ->
+              (Integer, Either r s)
+stepsLogic s lf es = let ies = D.genericLength . filter isTick $ es
+                     in (ies, logicFold lf s es)
+    where
+          isTick Tick = True
+          isTick _    = False
+
+          logicFold :: (s -> Event -> Either r s) ->
+                       Either r s -> [Event] -> Either r s
+          logicFold _ (Left r) _ = Left r
+          logicFold wlf (Right ws) wes = CM.foldM wlf ws wes
+
+
+-------------------------------------------------------------------------------
+-- Frame per Seconds
+
+data FPSCalc = FPSCalc [Integer] TPS
+    -- list with number of `Ticks` processed at each blit and expected
+    -- FPS (i.e. TPS)
+
+-- the size of moving average will be TPS (that simplifies calculations)
+creaFPSCalc :: TPS -> FPSCalc
+creaFPSCalc tps = FPSCalc (D.genericReplicate tps {- (tps*2) -} 1) tps
+    -- tps*1: size of thw window in **blit actions** (not tick actions!)
+    --        so keeping it small should be responsive and non flickery
+    --        at the same time!
+
+-- add ticks
+addFPS :: Integer -> FPSCalc -> FPSCalc
+addFPS nt (FPSCalc (_:fps) tps) = FPSCalc (fps ++ [nt]) tps
+addFPS _ (FPSCalc [] _) = error "addFPS: empty list."
+
+calcFPS :: FPSCalc -> Integer
+calcFPS (FPSCalc fps tps) =
+        let ts = sum fps
+            ds = D.genericLength fps
+        in roundQuot (tps * ds) ts
+    where
+          roundQuot :: Integer -> Integer -> Integer
+          roundQuot a b = let (q, r) = quotRem a b
+                          in q + B.bool 0 1 (r > div b 2)
diff --git a/src/Terminal/Game/Layer/Object.hs b/src/Terminal/Game/Layer/Object.hs
new file mode 100644
--- /dev/null
+++ b/src/Terminal/Game/Layer/Object.hs
@@ -0,0 +1,30 @@
+-------------------------------------------------------------------------------
+-- Layer 2 (mockable IO), as per
+-- https://www.parsonsmatt.org/2018/03/22/three_layer_haskell_cake.html
+-- 2019 Francesco Ariis GPLv3
+-------------------------------------------------------------------------------
+
+module Terminal.Game.Layer.Object ( module Export ) where
+
+import Terminal.Game.Layer.Object.Interface as Export
+import Terminal.Game.Layer.Object.GameIO    as Export
+import Terminal.Game.Layer.Object.Narrate   as Export
+import Terminal.Game.Layer.Object.Primitive as Export
+import Terminal.Game.Layer.Object.Record    as Export
+import Terminal.Game.Layer.Object.Test      as Export
+
+-- DESIGN NOTES --
+
+-- The classes are described in 'Interface'.
+
+-- The implemented monads are four:
+--     - GameIO (via MonadIO): playing the game
+--     - Test: testing the game in a pure manner
+--     - Record: playing the game and record the Events in a file
+--     - Replay: replay a game using a set of Events.
+--
+-- The last two monads (Record/Replay) take advantage of "overlapping
+-- instances". Instead of reimplementing most of what happens in MonadIO,
+-- they'll just touch the classes from interface which behaviour they
+-- will modify; being more specific, they will be chosen instead of plain
+-- IO.
diff --git a/src/Terminal/Game/Layer/Object/GameIO.hs b/src/Terminal/Game/Layer/Object/GameIO.hs
new file mode 100644
--- /dev/null
+++ b/src/Terminal/Game/Layer/Object/GameIO.hs
@@ -0,0 +1,21 @@
+-------------------------------------------------------------------------------
+-- Layer 2 (mockable IO), as per
+-- https://www.parsonsmatt.org/2018/03/22/three_layer_haskell_cake.html
+-- 2019 Francesco Ariis GPLv3
+-------------------------------------------------------------------------------
+
+{-# LANGUAGE GeneralizedNewtypeDeriving #-}
+
+
+module Terminal.Game.Layer.Object.GameIO where
+
+import qualified Control.Monad.Catch          as MC
+import qualified Control.Monad.Trans          as T
+
+
+newtype GameIO a = GameIO { runGIO :: IO a }
+                 deriving (Functor, Applicative, Monad,
+                           T.MonadIO,
+                           MC.MonadThrow, MC.MonadCatch, MC.MonadMask)
+
+
diff --git a/src/Terminal/Game/Layer/Object/IO.hs b/src/Terminal/Game/Layer/Object/IO.hs
new file mode 100644
--- /dev/null
+++ b/src/Terminal/Game/Layer/Object/IO.hs
@@ -0,0 +1,317 @@
+-------------------------------------------------------------------------------
+-- Layer 2 (mockable IO), as per
+-- https://www.parsonsmatt.org/2018/03/22/three_layer_haskell_cake.html
+-- 2019 Francesco Ariis GPLv3
+-------------------------------------------------------------------------------
+
+{-# LANGUAGE FlexibleInstances #-}
+{-# LANGUAGE UndecidableInstances #-}
+{-# OPTIONS_GHC -fno-warn-orphans #-}
+
+
+module Terminal.Game.Layer.Object.IO where
+
+import Terminal.Game.Utils
+
+import Terminal.Game.Layer.Object.Interface
+import Terminal.Game.Layer.Object.Primitive
+import Terminal.Game.Plane
+
+import qualified Control.Concurrent           as CC
+import qualified Control.Monad                as CM
+import qualified Control.Monad.Catch          as MC
+import qualified Control.Monad.Trans          as T
+import qualified GHC.IO.StdHandles            as GH
+import qualified Data.List.Split              as LS
+import qualified System.Clock                 as SC
+import qualified System.Console.ANSI          as CA
+import qualified System.Console.Terminal.Size as TS
+import qualified System.IO                    as SI
+
+-- Most General MonadIO operations.
+
+----------------
+-- Game input --
+----------------
+
+instance {-# OVERLAPS #-} (Monad m, T.MonadIO m) => MonadInput m where
+    startEvents tps = T.liftIO $ startIOInput tps
+    pollEvents ve = T.liftIO $ CC.swapMVar ve []
+    stopEvents ts = T.liftIO $ stopEventsIO ts
+    areEventsOver = return False
+      -- IO monad is the actual game, we never quit bar if
+      -- the logic function returns `Right`.
+
+
+-- filepath = logging
+startIOInput :: TPS -> IO InputHandle
+startIOInput tps =
+            SI.hSetBuffering SI.stdin SI.NoBuffering  >>
+            SI.hSetBuffering SI.stdout (SI.BlockBuffering Nothing) >>
+            SI.hSetEcho SI.stdin False                >>
+                -- all the buffering settings has to happen
+                -- at the top of startIOInput. If i move
+                -- them to display, you need to press enter
+                -- before playing the game on some machines.
+
+            -- event and log variables
+            CC.newMVar [] >>= \ve ->
+
+            getTimeTick tps               >>= \it ->
+            CC.forkIO (addTick ve tps it) >>= \te ->
+            CC.forkIO (addKeypress ve)    >>= \tk ->
+            return (InputHandle ve [te, tk])
+
+-- a precise timer, not based on `threadDelay`
+type Elapsed = Integer -- in `Ticks`
+
+-- elapsed from Epoch in ticks
+getTimeTick :: TPS -> IO Elapsed
+getTimeTick tps =
+        getTime >>= \tm ->
+        let ns = 10 ^ (9 :: Integer)
+            t1 = quot ns tps in
+        return (quot tm t1)
+
+-- mr: maybe recording
+addTick :: CC.MVar [Event] -> TPS -> Elapsed -> IO ()
+addTick ve tps el =
+                -- precise timing. With `treadDelay`, on finer TPS,
+                -- ticks take too much (check threadDelay doc).
+                getTimeTick tps                   >>= \t ->
+                CM.replicateM_ (fromIntegral $ t-el)
+                               (addEvent ve Tick) >>
+
+                -- sleep some
+                sleepABit tps >>
+                addTick ve tps t
+
+-- get action char
+-- mr: maybe recording
+addKeypress :: CC.MVar [Event] -> IO ()
+addKeypress ve = -- vedi platform-dep/
+                 inputCharTerminal        >>= \c ->
+                 addEvent ve (KeyPress c) >>
+                 addKeypress ve
+
+-- mr: maybe recording
+addEvent :: CC.MVar [Event] -> Event -> IO ()
+addEvent ve e = vf ve
+    where
+          vf d = CC.modifyMVar_ d (return . (++[e]))
+
+stopEventsIO :: [CC.ThreadId] -> IO ()
+stopEventsIO ts = do
+        mapM_ CC.killThread ts
+        SI.hSetBuffering SI.stdout SI.NoBuffering
+        -- We need this to make `alone-playback` work, see (thnks jrvieira):
+        -- https://stackoverflow.com/questions/27324354/haskell-compiled-io-actionorder-and-flushing
+
+-----------------
+-- Game timing --
+-----------------
+
+instance {-# OVERLAPS #-} (Monad m, T.MonadIO m) => MonadTimer m where
+    getTime = T.liftIO $ SC.toNanoSecs <$> SC.getTime SC.Monotonic
+    sleepABit tps = T.liftIO $
+        CC.threadDelay (fromIntegral $ quot oneTickSec (tps*10))
+
+--------------------
+-- Error handling --
+--------------------
+
+instance {-# OVERLAPS #-}
+        (Monad m, T.MonadIO m, MC.MonadMask m, MC.MonadThrow m) =>
+          MonadException m where
+    cleanUpErr m c = MC.finally m c
+    throwExc t = MC.throwM t
+
+-------------
+-- Display --
+-------------
+
+instance {-# OVERLAPS #-} (Monad m, T.MonadIO m) => MonadDisplay m where
+    setupDisplay = T.liftIO initPart
+    clearDisplay = T.liftIO clearScreen
+    displaySize = T.liftIO displaySizeIO
+    blitPlane mp p = T.liftIO (blitPlaneIO mp p)
+    shutdownDisplay = T.liftIO cleanAndExit
+
+displaySizeIO :: IO (Maybe Dimensions)
+displaySizeIO =
+        TS.size        >>= \ts ->
+            -- cannot use ansi-terminal, on Windows you get
+            -- "ConsoleException 87" (too much scrolling)
+            -- and it does not work for mintty and it is
+            -- inefficient as it gets (attempts to scroll past
+            -- bottom right)
+        isWin32Console >>= \bw ->
+            -- cmd.exe is present on Win10 `C:\Windows\system32\cmd.exe`
+            -- — and default — too. So this is needed for the foreseeable
+            -- future.
+
+        return (fmap (f bw) ts)
+    where
+          f :: Bool -> TS.Window Int -> Dimensions
+          f wbw (TS.Window h w) =
+                let h' | wbw       = h - 1
+                       | otherwise = h
+                in (w, h')
+
+-- pn: new plane, po: old plane
+-- wo, ho: dimensions of the terminal. If they change, reinit double buffering
+blitPlaneIO :: Maybe Plane -> Plane -> IO ()
+blitPlaneIO mpo pn =
+
+        -- remember that Nothing will be passed:
+        -- - at the beginning of the game (first blit)
+        -- - when resolution changes (see gameLoop)
+        -- so do not duplicate hasResChanged checks here!
+
+        -- old plane
+        let
+            (pw, ph) = planeSize pn
+            bp  = blankPlane pw ph
+            po  = pastePlane (maybe bp id mpo) bp (1, 1)
+        in
+
+        -- new plane
+        let pn'  = pastePlane pn bp (1, 1)
+        in
+
+            -- trimming is foundamental, as blitMap could otherwise print
+            -- outside terminal boundaries and scroll to its death
+            -- (error 87 on Win32 console).
+
+        CA.setSGR [CA.Reset] >>
+        blitMap po pn'
+
+
+-----------------
+-- ANCILLARIES --
+-----------------
+
+-- represent current terminal SGR State
+-- so we can keep track of it between blits
+data Style = Style { sBold     :: Bool
+                   , sReversed :: Bool
+                   , sColor    :: Maybe ColorInfo
+                   }
+           deriving (Eq)
+
+resetStyle :: Style
+resetStyle = Style False False Nothing
+
+cellToStyle :: Cell -> Style
+cellToStyle c = Style (isBold c) (isReversed c) (cellColor c)
+
+initPart :: IO ()
+initPart = -- check thread support
+           CM.unless CC.rtsSupportsBoundThreads
+                     (error errMes)             >>
+
+           -- initial setup/checks
+           CA.hideCursor >>
+           CA.hNowSupportsANSI GH.stdout >>
+             -- On Windows, tries to turn ANSI control
+             -- characters support on.
+
+           -- text encoding
+           SI.mkTextEncoding "UTF-8//TRANSLIT" >>= \te ->
+           SI.hSetEncoding SI.stdout te        >>
+
+           clearScreen
+    where
+          errMes = unlines
+            ["\nError: you *must* compile this program with -threaded!",
+             "Just add",
+             "",
+             "    ghc-options:      -threaded",
+             "",
+             "in your .cabal file (executable section) and you will be fine!"]
+
+-- clears screen
+clearScreen :: IO ()
+clearScreen = CA.setCursorPosition 0 0 >>
+              CA.setSGR [CA.Reset]     >>
+              displaySizeErr           >>= \(w, h) ->
+              CM.replicateM_ (fromIntegral $ w*h) (putChar ' ')
+
+cleanAndExit :: IO ()
+cleanAndExit = CA.setSGR [CA.Reset]     >>
+               CA.clearScreen           >>
+               CA.setCursorPosition 0 0 >>
+               CA.showCursor
+
+-- plane
+blitMap :: Plane -> Plane -> IO ()
+blitMap po pn =
+            CM.when (planeSize po /= planeSize pn)
+                    (error "blitMap: different plane sizes")      >>
+            CA.setCursorPosition 0 0                              >>
+                -- setCursorPosition is *zero* based!
+            blitToTerminal (0, 0) (orderedCells po) (orderedCells pn) >>
+            SI.hFlush SI.stdout
+
+orderedCells :: Plane -> [[Cell]]
+orderedCells p = LS.chunksOf (fromIntegral w) cells
+    where
+          cells  = map snd $ assocsPlane p
+          (w, _) = planeSize p
+
+-- ordered sequence of cells, both old and new, like they were a String to
+-- print to screen.
+-- Coords: initial blitting position
+-- Remember that this Column is *zero* based
+blitToTerminal :: Coords -> [[Cell]] -> [[Cell]] -> IO ()
+blitToTerminal (rr, rc) ocs ncs = CM.foldM_ blitLine (rr, resetStyle) oldNew
+    where
+          oldNew :: [[(Cell, Cell)]]
+          oldNew = zipWith zip ocs ncs
+
+          -- row = previous row, st = current terminal style
+          blitLine :: (Row, Style) -> [(Cell, Cell)] -> IO (Row, Style)
+          blitLine (pr, st) ccs =
+                CM.foldM blitCell (0, st) ccs    >>= \(_, st') ->
+                let wr = pr + 1 in
+                -- have to use setCursorPosition (instead of nextrow) b/c
+                -- on win there is an auto "go-to-next-line" when reaching
+                -- column end and on win it does not do so
+                CA.setCursorPosition (fromIntegral wr)
+                                     (fromIntegral rc) >>
+                return (wr, st')
+
+          -- k is "spaces to skip"
+          blitCell :: (Int, Style) -> (Cell, Cell) -> IO (Int, Style)
+          blitCell (k, st) (clo, cln)
+                | cln == clo = return (k+1, st)
+                | otherwise  = moveIf k >>= \k' ->
+                               putCellStyle st cln >>= \st' ->
+                               return (k', st')
+
+          moveIf :: Int -> IO Int
+          moveIf k | k == 0    = return k
+                   | otherwise = CA.cursorForward k >>
+                                 return 0
+
+putCellStyle :: Style -> Cell -> IO Style
+putCellStyle st c =
+        CM.when (st /= cst) (CA.setSGR ([CA.Reset] ++ sgrb ++ sgrr ++ sgrc)) >>
+        putChar (cellChar c) >>
+        return cst
+    where
+          cst = cellToStyle c
+
+          sgrb | isBold c  = [CA.SetConsoleIntensity CA.BoldIntensity]
+               | otherwise = []
+
+          sgrr | isReversed c = [CA.SetSwapForegroundBackground True]
+               | otherwise    = []
+
+          sgrc | Just (ANSIColorInfo (k, i)) <- cellColor c = [CA.SetColor CA.Foreground i k]
+               | Just (RGBColorInfo k)       <- cellColor c = [CA.SetRGBColor CA.Foreground k]
+               | Just (PaletteColorInfo k)   <- cellColor c = [CA.SetPaletteColor CA.Foreground k]
+               | otherwise                                  = []
+
+oneTickSec :: Integer
+oneTickSec = 10 ^ (6 :: Integer)
diff --git a/src/Terminal/Game/Layer/Object/Interface.hs b/src/Terminal/Game/Layer/Object/Interface.hs
new file mode 100644
--- /dev/null
+++ b/src/Terminal/Game/Layer/Object/Interface.hs
@@ -0,0 +1,60 @@
+-------------------------------------------------------------------------------
+-- Layer 2 (mockable IO), as per
+-- https://www.parsonsmatt.org/2018/03/22/three_layer_haskell_cake.html
+-- 2019 Francesco Ariis GPLv3
+-------------------------------------------------------------------------------
+
+{-# LANGUAGE ConstraintKinds #-}
+{-# LANGUAGE LambdaCase #-}
+
+module Terminal.Game.Layer.Object.Interface where
+
+import Terminal.Game.Plane
+import Terminal.Game.Layer.Object.Primitive
+
+import qualified Control.Concurrent as CC
+
+-------------------------------------------------------------------------------
+-- mtl interface for game
+
+type MonadGameIO m = (MonadInput m, MonadTimer m,
+                      MonadException m, MonadDisplay m)
+
+data InputHandle = InputHandle
+            { ihKeyMVar     :: CC.MVar [Event],
+              ihOpenThreads :: [CC.ThreadId] }
+
+class Monad m => MonadInput m where
+    startEvents :: TPS -> m InputHandle
+    pollEvents  :: CC.MVar [Event] -> m [Event]
+    stopEvents :: [CC.ThreadId] -> m ()
+    areEventsOver :: m Bool
+      -- Why do we need this? For test/narrate purposes. When
+      -- we play a game events are never over, but when we
+      -- test/narrate, it might be than the stream of [Event]
+      -- is exhausted before the state function returns Right.
+      -- We do not want to be stuck in an endless loop in that
+      -- case.
+
+class Monad m => MonadTimer m where
+    getTime :: m Integer     -- to nanoseconds
+    sleepABit :: TPS -> m () -- Given TPS, sleep a fracion of a single
+                             -- Tick.
+
+-- if a fails, do b (useful for cleaning up)
+class Monad m => MonadException m where
+    cleanUpErr :: m a -> m b -> m a
+    throwExc :: ATGException -> m a
+
+class Monad m => MonadDisplay m where
+    setupDisplay :: m ()
+    clearDisplay :: m ()
+    displaySize :: m (Maybe Dimensions)
+    blitPlane :: Maybe Plane -> Plane -> m ()
+    shutdownDisplay :: m ()
+
+displaySizeErr :: (MonadDisplay m, MonadException m) => m Dimensions
+displaySizeErr = displaySize >>= \case
+                   Nothing -> throwExc CannotGetDisplaySize
+                   Just d -> return d
+
diff --git a/src/Terminal/Game/Layer/Object/Narrate.hs b/src/Terminal/Game/Layer/Object/Narrate.hs
new file mode 100644
--- /dev/null
+++ b/src/Terminal/Game/Layer/Object/Narrate.hs
@@ -0,0 +1,28 @@
+{-# LANGUAGE GeneralizedNewtypeDeriving #-}
+
+module Terminal.Game.Layer.Object.Narrate where
+
+-- Narrate Monad, replay on screen from a GRec
+
+import Terminal.Game.Layer.Object.Interface
+import Terminal.Game.Layer.Object.Primitive
+import Terminal.Game.Layer.Object.IO () -- MonadIo
+
+import qualified Control.Monad.Catch as MC
+import qualified Control.Monad.State as S
+import qualified Control.Monad.Trans as T
+
+
+newtype Narrate a = Narrate (S.StateT GRec IO a)
+                deriving (Functor, Applicative, Monad,
+                          T.MonadIO, S.MonadState GRec,
+                          MC.MonadThrow, MC.MonadCatch, MC.MonadMask)
+
+instance MonadInput Narrate where
+    startEvents fps = T.liftIO $ startEvents fps
+    pollEvents _ = S.state getPolled
+    stopEvents ts = T.liftIO $ stopEvents ts
+    areEventsOver = S.gets isOver
+
+runReplay :: Narrate a -> GRec -> IO a
+runReplay (Narrate s) k = S.evalStateT s k
diff --git a/src/Terminal/Game/Layer/Object/Primitive.hs b/src/Terminal/Game/Layer/Object/Primitive.hs
new file mode 100644
--- /dev/null
+++ b/src/Terminal/Game/Layer/Object/Primitive.hs
@@ -0,0 +1,139 @@
+{-# LANGUAGE DeriveGeneric #-}
+{-# LANGUAGE LambdaCase #-}
+
+module Terminal.Game.Layer.Object.Primitive where
+
+import Terminal.Game.Plane
+
+import qualified Control.Monad.Catch as MC
+import qualified GHC.Generics as G
+import qualified Data.ByteString as BS
+import qualified Data.Serialize as Z
+import qualified Data.Sequence as S
+import qualified Test.QuickCheck as Q
+
+-------------------------------------------------------------------------------
+-- Assorted API types
+
+-- | The number of 'Tick's fed each second to the logic function;
+-- constant on every machine. /Frames/ per second might be lower
+-- (depending on drawing function onerousness, terminal refresh rate,
+-- etc.).
+type TPS = Integer
+
+-- | The number of frames blit to terminal per second. Frames might be
+-- dropped, but game speed will remain constant. Check @balls@
+-- (@cabal run -f examples balls@) to see how to display FPS.
+-- For obvious reasons (blits would be wasted) @max FPS = TPS@.
+type FPS = Integer
+
+-- | An @Event@ is a 'Tick' (time passes) or a 'KeyPress'.
+--
+-- Note that all @Keypress@es are recorded and fed to your game-logic
+-- function. This means you will not lose a single character, no matter
+-- how fast your player is at typing or how low you set 'FPS' to be.
+--
+-- Example: in a game where you are controlling a hot-air baloon and have
+-- @direction@ and @position@ variables, you most likely want @direction@
+-- to change at every @KeyPress@, while having @position@ only change at
+-- @Tick@s.
+data Event = Tick
+           | KeyPress Char
+              -- ↑↓→← do not work on Windows (are handled by the app,
+              -- not passed to the program) both on cmd.exe and
+              -- PowerShell.
+           deriving (Show, Eq, G.Generic)
+instance Z.Serialize Event where
+
+instance Q.Arbitrary Event where
+  arbitrary = Q.oneof [ pure Tick,
+                        KeyPress <$> Q.arbitrary ]
+
+-- | Game environment with current terminal dimensions and current display
+-- rate.
+data GEnv = GEnv { eTermDims :: Dimensions,
+                        -- ^ Current terminal dimensions.
+                   eFPS :: FPS
+                        -- ^ Current blitting rate.
+                       }
+    deriving (Show, Eq)
+
+-------------------------------------------------------------------------------
+-- GRec record/replay game typs
+
+-- | Opaque data type with recorded game input, for testing purposes.
+data GRec = GRec { aPolled :: S.Seq [Event],
+                                -- Seq. of polled events
+                   aTermSize :: S.Seq (Maybe Dimensions) }
+                                -- Seq. of polled termdims
+        deriving (Show, Eq, G.Generic)
+instance Z.Serialize GRec where
+
+igrec :: GRec
+igrec = GRec S.Empty S.Empty
+
+addDims :: Maybe Dimensions -> GRec -> GRec
+addDims mds (GRec p s) = GRec p (mds S.<| s)
+
+getDims :: GRec -> (Maybe Dimensions, GRec)
+getDims (GRec p (ds S.:|> d)) = (d, GRec p ds)
+getDims _ = error "getDims: empty Seq"
+    -- Have to use _ or “non exhaustive patterns” warning
+
+addPolled :: [Event] -> GRec -> GRec
+addPolled es (GRec p s) = GRec (es S.<| p) s
+
+getPolled :: GRec -> ([Event], GRec)
+getPolled (GRec (ps S.:|> p) d) = (p, GRec ps d)
+getPolled _ = error "getPolled: empty Seq"
+
+isOver :: GRec -> Bool
+isOver (GRec S.Empty _) = True
+isOver _ = False
+
+-- | Reads a file containing a recorded session. Throws
+-- 'MalformedGRec' on failure.
+readRecord :: FilePath -> IO GRec
+readRecord fp = Z.decode <$> BS.readFile fp >>= \case
+                  Left e  -> MC.throwM (MalformedGRec e)
+                  Right r -> return r
+
+-- | Convenience function to create a 'GRec' from screen size (constant) plus a list of events. Useful with 'setupGame'.
+createGRec :: Dimensions -> [Event] -> GRec
+createGRec ds es = let l = length es * 2 in
+                   GRec (S.fromList [es])
+                        (S.fromList . replicate l $ Just ds)
+
+-------------------------------------------------------------------------------
+-- Exceptions
+
+-- | @ATGException@s are thrown synchronously for easier catching.
+data ATGException = CannotGetDisplaySize
+                  | DisplayTooSmall Dimensions Dimensions
+                        -- ^ Required and actual dimensions.
+                  | MalformedGRec String
+        deriving (Eq)
+
+instance Show ATGException where
+    show CannotGetDisplaySize = "CannotGetDisplaySize"
+    show (DisplayTooSmall (sw, sh) tds) =
+      let colS ww = ww < sw
+          rowS wh = wh < sh
+
+          smallMsg :: Dimensions -> String
+          smallMsg (ww, wh) =
+                let cm = show ww ++ " columns"
+                    rm = show wh ++ " rows"
+                    em | colS ww && rowS wh = cm ++ " and " ++ rm
+                       | colS ww = cm
+                       | rowS wh = rm
+                       | otherwise = "smallMsg: passed correct term size!"
+                in
+                  "This games requires a display of " ++ show sw ++
+                  " columns and " ++ show sh ++ " rows.\n" ++
+                  "Yours only has " ++ em ++ "!\n\n" ++
+                  "Please resize your terminal and restart the game.\n"
+      in "DisplayTooSmall.\n" ++ smallMsg tds
+    show (MalformedGRec e) = "MalformedGRec: " ++ e
+
+instance MC.Exception ATGException where
diff --git a/src/Terminal/Game/Layer/Object/Record.hs b/src/Terminal/Game/Layer/Object/Record.hs
new file mode 100644
--- /dev/null
+++ b/src/Terminal/Game/Layer/Object/Record.hs
@@ -0,0 +1,54 @@
+{-# LANGUAGE GeneralizedNewtypeDeriving #-}
+
+module Terminal.Game.Layer.Object.Record where
+
+-- Record Monad, for when I need to play the game and record Events
+-- (keypresses, ticks, screen size, FPS) to a file.
+
+import Terminal.Game.Layer.Object.Interface
+import Terminal.Game.Layer.Object.Primitive
+import Terminal.Game.Layer.Object.IO ()
+
+import qualified Control.Concurrent   as CC
+import qualified Control.Monad.Catch  as MC
+import qualified Control.Monad.Reader as R
+import qualified Control.Monad.Trans  as T -- MonadIO
+import qualified Data.ByteString      as BS
+import qualified Data.Serialize       as S
+
+-- record the key pressed in a game session
+
+newtype Record a = Record (R.ReaderT (CC.MVar GRec) IO a)
+                deriving (Functor, Applicative, Monad,
+                          T.MonadIO, R.MonadReader (CC.MVar GRec),
+                          MC.MonadThrow, MC.MonadCatch, MC.MonadMask)
+
+-- Lifts IO interface, records where necessary
+instance MonadInput Record where
+    startEvents tps = T.liftIO (startEvents tps)
+    pollEvents ve = T.liftIO (pollEvents ve) >>= \es ->
+                    modMRec addPolled es
+    stopEvents ts = T.liftIO (stopEvents ts)
+    areEventsOver = T.liftIO areEventsOver
+
+instance MonadDisplay Record where
+    setupDisplay = T.liftIO setupDisplay
+    clearDisplay = T.liftIO clearDisplay
+    displaySize = T.liftIO displaySize >>= \ds ->
+                  modMRec addDims ds
+    blitPlane mp p = T.liftIO (blitPlane mp p)
+    shutdownDisplay = T.liftIO shutdownDisplay
+
+-- logs and passes the value on
+modMRec :: (a -> GRec -> GRec) -> a -> Record a
+modMRec f a = R.ask >>= \mv ->
+              let fmv = CC.modifyMVar_ mv (return . f a) in
+              T.liftIO fmv >>
+              return a
+
+runRecord :: Record a -> CC.MVar GRec -> IO a
+runRecord (Record r) me = R.runReaderT r me
+
+writeRec :: FilePath -> CC.MVar GRec -> IO ()
+writeRec fp vr = CC.readMVar vr                >>= \k ->
+                 BS.writeFile fp (S.encode k)
diff --git a/src/Terminal/Game/Layer/Object/Test.hs b/src/Terminal/Game/Layer/Object/Test.hs
new file mode 100644
--- /dev/null
+++ b/src/Terminal/Game/Layer/Object/Test.hs
@@ -0,0 +1,77 @@
+-------------------------------------------------------------------------------
+-- Layer 2 (mockable IO), as per
+-- https://www.parsonsmatt.org/2018/03/22/three_layer_haskell_cake.html
+-- 2019 Francesco Ariis GPLv3
+-------------------------------------------------------------------------------
+
+{-# LANGUAGE GeneralizedNewtypeDeriving #-}
+
+module Terminal.Game.Layer.Object.Test where
+
+-- Test (pure) MonadGame* typeclass implementation for testing purposes.
+
+import Terminal.Game.Layer.Object.Interface
+import Terminal.Game.Layer.Object.Primitive
+
+import qualified Control.Monad.Except as E
+import qualified Control.Monad.RWS as S
+import qualified Data.Bifunctor as B
+
+
+-----------
+-- TYPES --
+-----------
+
+data TestEvent = TCleanUpError
+               | TException ATGException
+               | TQuitGame
+               | TSetupDisplay
+               | TShutdownDisplay
+               | TStartGame
+               | TStartEvents
+               | TStopEvents
+        deriving (Eq, Show)
+
+-- e: ()
+-- r: ()
+-- w: [TestEvents]
+-- s: [GTest]
+newtype Test a = Test (E.ExceptT () (S.RWS () [TestEvent] GRec) a)
+               deriving (Functor, Applicative, Monad,
+                         E.MonadError (), S.MonadState GRec,
+                         S.MonadWriter [TestEvent])
+
+runTest :: Test a -> GRec -> (Maybe a, [TestEvent])
+runTest (Test em) es = let m = E.runExceptT em
+                           t = S.evalRWS m () es in
+                       B.first (either (const Nothing) Just) t
+
+-------------------------------------------------------------------------------
+-- Class
+
+mockHandle :: InputHandle
+mockHandle = InputHandle (error "mock handle keyMvar")
+                         (error "mock handle threads")
+
+instance MonadInput Test where
+    startEvents _ = S.tell [TStartEvents] >>
+                    return mockHandle
+    pollEvents _ = S.state getPolled
+    stopEvents _ = S.tell [TStopEvents]
+    areEventsOver = S.gets isOver
+
+instance MonadTimer Test where
+    getTime = return 1
+    sleepABit _ = return ()
+
+instance MonadException Test where
+    cleanUpErr a _ = S.tell [TCleanUpError] >> a
+    throwExc e = S.tell [TException e] >>
+                 E.throwError ()
+
+instance MonadDisplay Test where
+    setupDisplay = () <$ S.tell [TSetupDisplay]
+    clearDisplay = return ()
+    displaySize = Test $ S.state getDims
+    blitPlane _ _ = return ()
+    shutdownDisplay = () <$ S.tell [TShutdownDisplay]
diff --git a/src/Terminal/Game/Plane.hs b/src/Terminal/Game/Plane.hs
--- a/src/Terminal/Game/Plane.hs
+++ b/src/Terminal/Game/Plane.hs
@@ -9,156 +9,250 @@
 
 module Terminal.Game.Plane where
 
-import qualified GHC.Generics as G
+import Terminal.Game.Character
+
 import qualified Data.Array as A
-import qualified Data.Char as C
-import qualified Data.List as L
+import qualified Data.Bifunctor as B
+import qualified Data.Colour.RGBSpace as S
 import qualified Data.List.Split as LS
 import qualified Data.Tuple as T
+import qualified Data.Word as W
+import qualified GHC.Generics as G
+import qualified System.Console.ANSI as CA
 
 
 ----------------
 -- DATA TYPES --
 ----------------
 
-type Width  = Integer
-type Height = Integer
-type Row    = Integer
-type Column = Integer
-type Coords = (Row, Column) -- row, column, from TL (TL = 1, 1)
+-- | 'Row's and 'Column's are 1-based (top-left position is @1 1@).
+type Coords = (Row, Column)
+type Row    = Int
+type Column = Int
 
+-- | Size of a surface in 'Row's and 'Column's.
+type Dimensions = (Width, Height)
+
+-- | Expressed in 'Column's.
+type Width  = Int
+-- | Expressed in 'Row's.
+type Height = Int
+
+type Bold     = Bool
+type Reversed = Bool
+
+data ColorInfo = ANSIColorInfo (CA.Color, CA.ColorIntensity)
+               | RGBColorInfo (S.Colour Float)
+               | PaletteColorInfo W.Word8
+               deriving (Show, Eq)
+
 -- can be an ASCIIChar or a special, transparent character
-data Cell = CellChar Char
+data Cell = CellChar Char Bold Reversed (Maybe ColorInfo)
           | Transparent
-          deriving (Show, Eq, Ord, G.Generic)
+          deriving (Show, Eq, G.Generic)
+        -- I found no meaningful speed improvements by making this
+        -- only w/ 1 constructor.
 
--- A place where to blit stuff. Coordinates starts from top left
--- corner (1, 1)
-newtype Plane = Plane { fromPlane :: (A.Array Coords Cell) }
+-- | A two-dimensional surface (Row, Column) where to blit stuff.
+newtype Plane = Plane { fromPlane :: A.Array Coords Cell }
               deriving (Show, Eq, G.Generic)
+        -- Could this be made into an UArray? Nope, since UArray is
+        -- only instanced on Words, Int, Chars, etc.
 
+-------------------------------------------------------------------------------
+-- Plane interface (abstracting Array)
+
+listPlane :: Coords -> [Cell] -> Plane
+listPlane (r, c) cs = Plane $ A.listArray ((1,1), (r, c)) cs
+
+-- | Dimensions or a plane.
+planeSize :: Plane -> Dimensions
+planeSize p = T.swap . snd $ A.bounds (fromPlane p)
+
+assocsPlane :: Plane -> [(Coords, Cell)]
+assocsPlane p = A.assocs (fromPlane p)
+
+elemsPlane :: Plane -> [Cell]
+elemsPlane p = A.elems (fromPlane p)
+
+-- Array.//
+updatePlane :: Plane -> [(Coords, Cell)] -> Plane
+updatePlane (Plane a) kcs = Plane $ a A.// kcs
+
+-- faux map
+mapPlane :: (Cell -> Cell) -> Plane -> Plane
+mapPlane f (Plane a) = Plane $ fmap f a
+
+
 ----------
 -- CREA --
 ----------
 
 creaCell :: Char -> Cell
-creaCell ch = CellChar ch
-
--- creates plane from a string, good to import ascii art/diagrams/etc.
--- Char indicates transparency, integer = pic width
-stringPlane :: Maybe Char -> Integer -> String -> Plane
-stringPlane mc w t = vitrous
+creaCell ch = CellChar chm False False Nothing
     where
-          lined = lines t
+          chm = win32SafeChar ch
 
-          h :: Integer
-          h = L.genericLength lined
+colorCell :: CA.Color -> CA.ColorIntensity -> Cell -> Cell
+colorCell k i (CellChar c b r _) = CellChar c b r (Just $ ANSIColorInfo (k, i))
+colorCell _ _ Transparent        = Transparent
 
-          pad :: Integer -> String -> String
-          pad mw t = take (fromIntegral mw) (t ++ repeat ' ')
+rgbColorCell :: S.Colour Float -> Cell -> Cell
+rgbColorCell k (CellChar c b r _) = CellChar c b r (Just $ RGBColorInfo k)
+rgbColorCell _ Transparent        = Transparent
 
-          padded :: [String]
-          padded = map (pad w) lined
+paletteColorCell :: W.Word8 -> Cell -> Cell
+paletteColorCell k (CellChar c b r _) = CellChar c b r (Just $ PaletteColorInfo k)
+paletteColorCell _ Transparent        = Transparent
 
-          celled :: [Cell]
-          celled = map creaCell . concat $ padded
+boldCell :: Cell -> Cell
+boldCell (CellChar c _ r k) = CellChar c True r k
+boldCell Transparent        = Transparent
 
-          plane :: Plane
-          plane = Plane $ A.listArray ((1,1), (h, w)) celled
+reverseCell :: Cell -> Cell
+reverseCell (CellChar c b _ k) = CellChar c b True k
+reverseCell Transparent        = Transparent
 
-          vitrous :: Plane
-          vitrous = case mc of
-                      Just c  -> addVitrum c plane
-                      Nothing -> plane
+-- | Creates a 'Plane' from a list of individually styled cells.
+-- More efficient than folding ('&') when drawing many cells
+-- as it performs a single array update instead of one per cell.
+-- Cells outside the plane bounds are silently ignored.
+cellsPlane :: Width -> Height -> [(Coords, Cell)] -> Plane
+cellsPlane w h cells = updatePlane (blankPlane w h) (filter inside cells)
+    where
+          inside ((r, c), _) = r >= 1 && r <= h && c >= 1 && c <= w
 
+-- | Creates 'Plane' from 'String', good way to import ASCII
+-- art/diagrams. Returns a 1×1 transparent plane on empty string.
+stringPlane :: String -> Plane
+stringPlane t = stringPlaneGeneric Nothing t
 
--- creates an empty, opaque Plane (limits: TL, BR)
+-- | Same as 'stringPlane', but with transparent 'Char'.
+-- Returns a 1×1 transparent plane on empty string.
+stringPlaneTrans :: Char -> String -> Plane
+stringPlaneTrans c t = stringPlaneGeneric (Just c) t
+
+-- | Creates an empty, opaque 'Plane'.
 blankPlane :: Width -> Height -> Plane
-blankPlane w h = Plane $ A.listArray ((1,1), (h, w)) (repeat $ creaCell ' ')
+blankPlane w h = listPlane (h, w) (repeat $ creaCell ' ')
 
--- add transparency to a plane, matching a given character
-addVitrum :: Char -> Plane -> Plane
-addVitrum tc p = mapPlane f p
+-- | Adds transparency to a plane, matching a given character
+makeTransparent :: Char -> Plane -> Plane
+makeTransparent tc p = mapPlane f p
     where
           f cl | cellChar cl == tc = Transparent
                | otherwise         = cl
 
+-- | Changes every transparent cell in the 'Plane' to an opaque @' '@
+-- character.
+makeOpaque :: Plane -> Plane
+makeOpaque p = let (w, h) = planeSize p
+               in pastePlane p (blankPlane w h) (1, 1)
 
+
+
 -----------
 -- SLICE --
 -----------
 
--- copies a slice of the plane (bl, tr)
-copyPlane :: Plane -> Coords -> Coords -> Plane
-copyPlane p (r1, c1) (r2, c2) =
-            Plane $ A.listArray ((1, 1), (w', h')) (map snd section)
-    where
-          inside ((r, c), _) | r >= r1 && r <= r2 &&
-                               c >= c1 && c <= c2    = True
-                             | otherwise             = False
-
-          (w, h) = planeSize p
-
-          w' = min w c2 - max c1 1 + 1
-          h' = min h r2 - max r1 1 + 1
-
-          section = filter inside (assocsPlane p)
-
--- paste one plane over the other at a certain position (p1 gets over p2).
--- Remember that coordinates start from bottom left!
--- Maybe char = possible transparency
+-- | Paste one plane over the other at a certain position (p1 gets over p2).
 pastePlane :: Plane -> Plane -> Coords -> Plane
-pastePlane p1 p2 (r, c) = updatePlane p2 filtered
+pastePlane p1 p2 (r, c)
+            | r > h2 || c > w2 = p2
+            | otherwise =
+                let ks = assocsPlane p1
+                    fs = filter (\x -> solid x && inside x) ks
+                    ts = fmap (B.first trasl) fs
+                in updatePlane p2 ts
     where
-          cs        = assocsPlane p1
-          (w2, h2)  = planeSize p2
-          traslated = fmap (\((r1, c1), cl) -> ((r1 + r - 1, c1 + c -1), cl))
-                           cs
-          filtered  = filter (\x -> inside x && solid x) traslated
+          trasl :: Coords -> Coords
+          trasl (wr, wc) = (wr + r - 1, wc + c - 1)
 
-          inside ((r1, c1), _) | r1 >= 1 && r1 <= h2 &&
-                                 c1 >= 1 && c1 <= w2    = True
-                               | otherwise              = False
+          -- inside new position, cheaper than first mapping and then
+          -- filtering.
+          inside (wcs, _) =
+                let (r1', c1') = trasl wcs
+                in r1' >= 1 && r1' <= h2 &&
+                   c1' >= 1 && c1' <= w2
 
           solid (_, Transparent) = False
-          solid (_, otherwise)   = True
+          solid _                = True
 
+          (w2, h2)  = planeSize p2
 
+-- | Cut out a plane by top-left and bottom-right coordinates.
+-- Returns a 1×1 transparent plane when @r1>r2@ or @c1>c2@.
+subPlane :: Plane -> Coords -> Coords -> Plane
+subPlane p (r1, c1) (r2, c2)
+        | r1 > r2 || c1 > c2 = makeTransparent ' ' (blankPlane 1 1)
+        | otherwise          =
+            let cs       = assocsPlane p
+                fs       = filter f cs
+                (pw, ph) = planeSize p
+                (w, h)   = (min pw (c2-c1+1), min ph (r2-r1+1))
+            in listPlane (h, w) (map snd fs)
+    where
+          f ((rw, cw), _) = rw >= r1 && rw <= r2 &&
+                            cw >= c1 && cw <= c2
+
 -------------
 -- INQUIRE --
 -------------
 
-planeSize :: Plane -> (Width, Height)
-planeSize p = T.swap . snd $ A.bounds (fromPlane p)
-
 cellChar :: Cell -> Char
-cellChar (CellChar ch) = ch
-cellChar Transparent    = ' '
+cellChar (CellChar c _ _ _) = c
+cellChar Transparent        = ' '
 
-assocsPlane :: Plane -> [(Coords, Cell)]
-assocsPlane p = A.assocs (fromPlane p)
+cellColor :: Cell -> Maybe ColorInfo
+cellColor (CellChar _ _ _ k) = k
+cellColor Transparent        = Nothing
 
--- an '\n' divided (and ended) String ready to be written on file
-paperPlane :: Plane -> String
-paperPlane p = unlines . LS.chunksOf w .
-               map c2c . A.elems $ fromPlane p
+isBold :: Cell -> Bool
+isBold (CellChar _ b _ _) = b
+isBold _                  = False
+
+isReversed :: Cell -> Bool
+isReversed (CellChar _ _ r _) = r
+isReversed _                  = False
+
+-- | A String (@\\n@ divided and ended) representing the 'Plane'. Useful
+-- for debugging/testing purposes.
+planePaper :: Plane -> String
+planePaper p = unlines . LS.chunksOf w . map cellChar $ elemsPlane p
     where
           w :: Int
           w = fromIntegral . fst . planeSize $ p
 
-          c2c :: Cell -> Char
-          c2c Transparent  = ' '
-          c2c (CellChar c) = c
-
-
 -----------------
 -- ANCILLARIES --
 -----------------
 
--- faux map
-mapPlane :: (Cell -> Cell) -> Plane -> Plane
-mapPlane f (Plane a) = Plane $ fmap f a
+stringPlaneGeneric :: Maybe Char -> String -> Plane
+stringPlaneGeneric _ "" = makeTransparent ' ' (blankPlane 1 1)
+stringPlaneGeneric mc t = vitrous
+    where
+          lined = lines t
 
--- Array.//
-updatePlane :: Plane -> [(Coords, Cell)] -> Plane
-updatePlane (Plane a) kcs = Plane $ a A.// kcs
+          h :: Int
+          h = length lined
+
+          w :: Int
+          w = maximum (map length lined)
+
+          pad :: Int -> String -> String
+          pad mw tl = take mw (tl ++ repeat ' ')
+
+          padded :: [String]
+          padded = map (pad w) lined
+
+          celled :: [Cell]
+          celled = map creaCell . concat $ padded
+
+          plane :: Plane
+          plane = listPlane (h, w) celled
+
+          vitrous :: Plane
+          vitrous = case mc of
+                      Just c  -> makeTransparent c plane
+                      Nothing -> plane
+
diff --git a/src/Terminal/Game/Random.hs b/src/Terminal/Game/Random.hs
new file mode 100644
--- /dev/null
+++ b/src/Terminal/Game/Random.hs
@@ -0,0 +1,20 @@
+module Terminal.Game.Random ( R.StdGen,
+                              R.UniformRange,
+                              R.getStdGen,
+                              R.mkStdGen,
+                              getRandom,
+                              pickRandom )
+            where
+
+import System.Random as R
+
+
+-- | Simple, pure pseudo-random generator.
+getRandom :: UniformRange a => (a, a) -> StdGen -> (a, StdGen)
+getRandom bs sg = uniformR bs sg
+
+-- | Picks at random from list.
+pickRandom :: [a] -> StdGen -> (a, StdGen)
+pickRandom as sg = let l = length as
+                       (a, sg') = getRandom (0, l-1) sg
+                   in (as !! a, sg')
diff --git a/src/Terminal/Game/Utils.hs b/src/Terminal/Game/Utils.hs
deleted file mode 100644
--- a/src/Terminal/Game/Utils.hs
+++ /dev/null
@@ -1,11 +0,0 @@
-module Terminal.Game.Utils where
-
-import Terminal.Game.Plane
-
-import qualified System.Console.Terminal.Size as TS
-
-screenSize :: IO (Width, Height)
-screenSize =
-        TS.size >>= \ts ->
-        let (TS.Window h w) = maybe (error "cannot get TERM size") id ts
-        in return (w, h)
diff --git a/test/Terminal/Game/DrawSpec.hs b/test/Terminal/Game/DrawSpec.hs
new file mode 100644
--- /dev/null
+++ b/test/Terminal/Game/DrawSpec.hs
@@ -0,0 +1,68 @@
+module Terminal.Game.DrawSpec where
+
+import Test.Hspec
+import Terminal.Game.Plane
+import Terminal.Game.Draw
+import Terminal.Game -- language hyphenators
+
+
+spec :: Spec
+spec = do
+
+  describe "mergePlanes" $ do
+    it "piles multiple planes together" $
+      mergePlanes (stringPlane "aa")
+                  [((1,2), cell 'b')] `shouldBe` stringPlane "ab"
+    it "works in the middle too" $
+      mergePlanes (stringPlane "aaa\naaa\naaa")
+                  [((2,2), cell 'b')] `shouldBe`
+                    stringPlane "aaa\naba\naaa"
+
+  describe "textBox/textBoxLiquid" $ do
+    let s  = "las rana in Spa"
+        w  = 6
+        ps = textBox w 2 s
+        pl = textBoxLiquid w s
+    it "textBox follows specific size" $
+      planeSize ps `shouldBe` (6, 2)
+    it "textBoxLiquid fits the whole string" $
+      planeSize pl `shouldBe` (6, 3)
+    it "textBox should make a transparent plane" $
+      let p1 = textBox 6 1 "a c e "
+          p2 = textBox 6 1 " b d f"
+          pc = p1 & (1, 1) % p2
+      in planePaper pc `shouldBe` "abcdef\n"
+
+  describe "textBoxHypen" $ do
+    let tbh = textBoxHyphen spanish 8 2 "Con pianito"
+    it "hyphens long words" $
+      planePaper tbh `shouldSatisfy` elem '-'
+
+  describe "***" $ do
+    let a  = stringPlane ".\n.\n.\n"
+        b  = stringPlane "*"
+        c  = stringPlane ".\n*\n.\n"
+    it "blits b in the centre of a" $
+      a *** b `shouldBe` c
+
+  -- combinators
+
+  let sp = stringPlane "ab"
+      bp = blankPlane 4 3
+
+  describe "%^>" $ do
+    it "blits in the top right corner" $
+      planePaper (bp & (1,1) %^> sp) `shouldBe` "  ab\n    \n    \n"
+
+  describe "%_<" $ do
+    it "blits in the bottom left corner" $
+      planePaper (bp & (2,1) %.< sp) `shouldBe` "    \nab  \n    \n"
+
+  describe "%_<" $ do
+    it "blits in the bottom left corner" $
+      planePaper (bp & (2,3) %.> sp) `shouldBe` "    \nab  \n    \n"
+
+  describe "%" $ do
+    it "mixes with alternative combinators" $
+      planePaper (bp & (1,2) % sp & (2,3) %.> sp) `shouldBe`
+        " ab \nab  \n    \n"
diff --git a/test/Terminal/Game/Layer/ImperativeSpec.hs b/test/Terminal/Game/Layer/ImperativeSpec.hs
new file mode 100644
--- /dev/null
+++ b/test/Terminal/Game/Layer/ImperativeSpec.hs
@@ -0,0 +1,72 @@
+module Terminal.Game.Layer.ImperativeSpec where
+
+import Terminal.Game.Layer.Imperative
+import Terminal.Game.Layer.Object
+import Terminal.Game.Random
+import Alone
+import Balls
+
+import Test.Hspec
+import Test.Hspec.QuickCheck
+
+import qualified Control.Exception as E
+import qualified Test.QuickCheck as Q
+import qualified GHC.Exts as X
+
+-- Test for state.
+stateTest :: Show r => Game s r -> GRec -> s
+stateTest g r = either em id (testGame g r)
+    where
+          em wr = error $ "stateTest: " ++ show wr
+
+spec :: Spec
+spec = do
+
+  describe "runGame" $ do
+    let nd = error "<not-defined>"
+        s :: (Integer, Bool, Integer)
+        s = (0, False, 0)
+        lf (t, True, i) Tick         = Right (t+1, True, i+1)
+        lf (t, b,    i) Tick         = Right (t+1, b,    i  )
+        lf (t, _,    i) (KeyPress _) = Right (t,   True, i  )
+        es = [Tick, KeyPress 'c', KeyPress 'c', Tick, Tick]
+        g :: Game (Integer, Bool, Integer) ()
+        g = Game nd s (const lf) nd
+    it "does not confuse input and logic" $
+      stateTest g (createGRec (80, 24) es) `shouldBe` (3, True, 2)
+
+  describe "testGame" $ do
+    it "tests a game" $ do
+        r <- readRecord "test/records/alone-record-test.gr"
+        stateTest aloneInARoom r `shouldBe` MyState (20, 66) Stop
+    it "tests a game exiting correctly" $ do
+        r <- readRecord "test/records/alone-record-left.gr"
+        testGame aloneInARoom r `shouldBe` Left ()
+    it "picks up screen resize events" $ do
+        r <- readRecord "test/records/balls-dims.gr"
+        let g = fireworks (mkStdGen 1)
+            t = stateTest g r
+        length (balls t) `shouldBe` 1
+    it "picks FPS too" $ do
+        r <- readRecord "test/records/balls-slow.gr"
+        let g = fireworks (mkStdGen 1)
+            t = stateTest g r
+        bslow t `shouldBe` True
+    it "does not hang on empty/unclosed input" $
+        let w = createGRec (80, 24) [Tick] in
+        stateTest aloneInARoom w `shouldBe` MyState (10, 10) Stop
+    modifyMaxSize (const 1000) $
+      it "does not crash/hang on random input" $ Q.property $
+        let genEvs = Q.listOf1 Q.arbitrary
+        in Q.forAll genEvs $
+             \es -> let w = createGRec (80, 24) es
+                        a = testGame aloneInARoom w
+                    in a == a
+    it "fails with an informative message" $ do
+        r <- readRecord "test/records/alone-record-test.gr"
+        let r' = r { aTermSize = X.fromList (replicate 1000 Nothing) }
+            t = testGame aloneInARoom r'
+            e = "testGame, exception called: [TSetupDisplay,TStartEvents,\
+                \TException CannotGetDisplaySize]"
+        E.evaluate t `shouldThrow` errorCall e
+
diff --git a/test/Terminal/Game/Layer/Object/TestSpec.hs b/test/Terminal/Game/Layer/Object/TestSpec.hs
new file mode 100644
--- /dev/null
+++ b/test/Terminal/Game/Layer/Object/TestSpec.hs
@@ -0,0 +1,19 @@
+module Terminal.Game.Layer.Object.TestSpec where
+
+import Terminal.Game.Layer.Imperative
+import Terminal.Game.Layer.Object
+import Alone
+
+import Test.Hspec
+
+import qualified GHC.Exts as E
+
+spec :: Spec
+spec = do
+
+  describe "runTest" $ do
+    it "logs exceptions without failing" $ do
+        r <- readRecord "test/records/alone-record-test.gr"
+        let r' = r { aTermSize = E.fromList (replicate 1000 Nothing) }
+            t = runTest (runGameGeneral aloneInARoom) r'
+        last (snd t) `shouldBe` TException CannotGetDisplaySize
diff --git a/test/Terminal/Game/PlaneSpec.hs b/test/Terminal/Game/PlaneSpec.hs
new file mode 100644
--- /dev/null
+++ b/test/Terminal/Game/PlaneSpec.hs
@@ -0,0 +1,57 @@
+module Terminal.Game.PlaneSpec where
+
+import Test.Hspec
+import Terminal.Game.Plane
+import Terminal.Game.Draw
+
+
+spec :: Spec
+spec = do
+
+  let testPlane =         blankPlane 2 2 &
+                  (1,1) % box 2 2 '.'    &
+                  (1,2) % cell ' '
+
+  describe "listPlane" $ do
+    it "creates a plane from string" $
+      listPlane (2,2) (map creaCell ". ..") `shouldBe` testPlane
+    it "ignores extra characters" $
+      listPlane (2,2) (map creaCell ". ..abc") `shouldBe` testPlane
+
+  describe "pastePlane" $ do
+    it "pastes a simple plane onto another" $
+      pastePlane (cell 'a') (cell 'b') (1,1) `shouldBe` cell 'a'
+
+  describe "stringPlane" $ do
+    it "creates plane from spec" $
+      stringPlane ".\n.." `shouldBe` testPlane
+
+  describe "stringPlaneTrans" $ do
+    it "allows transparency" $
+      stringPlaneTrans '.' ".\n.." `shouldBe` makeTransparent '.' testPlane
+
+  describe "updatePlane" $ do
+    let ma = listPlane (2,1) (map creaCell "ab")
+        mb = listPlane (2,1) (map creaCell "xb")
+    it "updates a Plane" $
+      updatePlane ma [((1,1), creaCell 'x')] `shouldBe` mb
+
+  describe "subPlane" $ do
+    let pa = word "prova" === word "fol"
+    it "cuts out a plane" $
+      planePaper (subPlane pa (1, 1) (2, 1)) `shouldBe` "p\nf\n"
+    it "does not crash on OOB" $
+      planeSize (subPlane pa (1, 1) (10, 10)) `shouldBe` (5, 2)
+    it "does not err on inconsistent coords" $
+      subPlane pa (2, 3) (1, 1) `shouldBe`
+        (blankPlane 1 1 # makeTransparent ' ')
+    it "but not on a single cell" $
+      subPlane pa (2, 3) (2, 3) `shouldBe` cell 'l'
+
+  describe "hcat/vcat" $ do
+    let pa = blankPlane 2 1
+        pb = blankPlane 3 4
+    it "concats planes horizontally with hcat" $
+      planeSize (hcat [pa, pb]) `shouldBe` (5, 4)
+    it "concats planes horizontally with vcat" $
+      planeSize (vcat [pa, pb]) `shouldBe` (3, 5)
diff --git a/test/Terminal/Game/RandomSpec.hs b/test/Terminal/Game/RandomSpec.hs
new file mode 100644
--- /dev/null
+++ b/test/Terminal/Game/RandomSpec.hs
@@ -0,0 +1,20 @@
+module Terminal.Game.RandomSpec where
+
+import Test.Hspec
+import Test.Hspec.QuickCheck
+import Terminal.Game.Random
+
+
+spec :: Spec
+spec = do
+
+  describe "pickRandom" $ do
+    prop "picks items at random from a list" $
+      \i -> let g = mkStdGen i
+            in fst (pickRandom ['a', 'b'] g) /= 'c'
+    prop "does not exclude any item" $
+      \i -> let g = mkStdGen i
+                rf tg = pickRandom [1,2] tg
+                rs = iterate (\(_, lg') -> rf lg')  (rf g)
+                ts = take 100 rs
+            in sum (map fst ts) /= length ts
diff --git a/test/records/alone-record-left.gr b/test/records/alone-record-left.gr
new file mode 100644
Binary files /dev/null and b/test/records/alone-record-left.gr differ
diff --git a/test/records/alone-record-test.gr b/test/records/alone-record-test.gr
new file mode 100644
Binary files /dev/null and b/test/records/alone-record-test.gr differ
diff --git a/test/records/balls-dims.gr b/test/records/balls-dims.gr
new file mode 100644
Binary files /dev/null and b/test/records/balls-dims.gr differ
diff --git a/test/records/balls-slow.gr b/test/records/balls-slow.gr
new file mode 100644
Binary files /dev/null and b/test/records/balls-slow.gr differ