kivy/doc/sources/philosophy.rst

Philosophy
==========

In case you are wondering what Kivy is all about and sets it apart from
different solutions, this document is for you.

Why bother?
-----------

Why would you want to use Kivy? After all, there is many a great toolkit
(or framework, or platform) available out there -- for free. Qt and Flash,
to just name two good choices for application development, and many of
these numerous solutions already support Multi-Touch.
So what is it that makes Kivy special and worth using?


                Fresh
                    Kivy is made for today and tomorrow. Novel input
                    methods such as Multi-Touch become increasingly
                    important. We created Kivy from scratch, specifically
                    for this kind of interaction. That means we were able
                    to rethink many things in terms of human computer
                    interaction where older (not saying 'outdated'; rather
                    'well-established') toolkits carry their legacy, which
                    is often a burden. We're not trying to force this new
                    approach to using a computer into the corset of
                    existing models (say single-pointer mouse interaction).
                    We want to let it flourish and let you explore the
                    possibilities.
                    *This* is what really sets Kivy apart.

                Fast
                    Kivy is fast. This applies to both: *application
                    development* and *application execution* speeds. We have
                    optimized Kivy in many ways. We implement time-critical
                    functionality on the *C level* to leverage the power of
                    existing compilers. More importantly, we also use
                    *intelligent algorithms* to minimize costly operations.
                    Most importantly, we use the *GPU* wherever it makes
                    sense in our context. The computational power of
                    today's graphics cards surpasses that of today's CPUs by
                    far for some tasks and algorithms, especially drawing.
                    That's why we try to let the GPU do as much of the work
                    as possible, thus increasing performance considerably.

                Flexible
                    Kivy is flexible. This means it can be run on *a variety of
                    different devices*, including Android powered
                    smartphones and tablets. We support *all major
                    operating systems* (Windows, Linux, OS X).
                    Being flexible also means that Kivy's fast-paced development
                    allows it to *adapt to new technologies quickly*.
                    More than once have we added support for new external
                    devices and software protocols; sometimes even before
                    they were released.
                    Lastly, Kivy is also flexible in that it is possible
                    to use it in combination with a great number of different
                    third-party solutions. For example, on Windows we
                    support WM_TOUCH, which means that any device that has
                    Windows 7 Pen & Touch drivers will *just work* with
                    Kivy. On OS X you can use Apple's Multi-Touch capable
                    devices, such as trackpads and mice. On Linux, you
                    can use HID kernel input events.
                    In addition to that, we support TUIO and a number of
                    other input sources.

                Focused
                    Kivy is focused. You can write a simple application
                    with a few lines of code. Kivy programs are created by
                    using the *Python* programming language, which is
                    incredibly versatile, powerful yet easy to use.
                    In addition, we created our own description language,
                    the *Kivy Language*, for creating sophisticated user
                    interfaces. This
                    language allows you to set up, connect and arrange your
                    application elements quickly.
                    We feel that allowing you to focus on the essence of
                    your application is more important than forcing you to
                    fiddle with compiler settings. We took that burden off
                    your shoulders.

                Funded
                    Kivy is actively developed by professionals in their field.
                    Kivy is a community-influenced, professionally
                    developed and commercially backed solution. Some of
                    our core developers develop Kivy for a living.
                    Kivy is here to stay. It's not a small, vanishing student
                    project.

                Free
                    Kivy is free to use. You don't have to pay for it. You
                    don't even have to pay for it if you're making money out
                    of selling an application that uses Kivy.