What is pyvm
------------

 It's a reimplementation of various userspace programs under a common
 dynamic language runtime system.  What's special about pyvm is that
 this dynamic runtime is not a general purpose vm/language; it's not
 supposed to be used by code outside the project and for that it does
 not have backwards compatibility.  The various implemented userspace
 programs are the only testcase that drives the evolution of the vm.
 Similarily, various libraries do not have fixed public APIs and so
 it's easier to make temporary implementations that can be used in
 order to bootstrap something else, and be refactored later.

 The core vm is a cousing of python and can even run small python
 programs, but 100% compatibility and passing python's test suite is
 not a goal.  Using a dynamic language offers some very important
 advantages like: automatic memory managment, no segfaults, exceptions,
 stackless threading, no need for recompilation, and generally the
 common runtime object system that can be used for very powerful and
 flexible inter-library APIs. On the other hand, pyvm likes C and based
 on the theory that 90% of the time of a program is spent in 10% of the
 code we try to move that part of the code in C and have the core
 program control in the scripting language; this has turned out to work
 very well (and at times even better than Just In Time compilation)

 pyvm does a *lot* of things and it's a tool that makes creating
 applications easy. However, it's not supposed to actually replace the
 existing userspace toolchains any time soon. It is more like a
 half-finished hobby project that may be suitable for people who prefer
 to use software they have written and can easilly modify.

 Existing userspace systems have some problems. One of them is very
 often the "dependancy hell" where building the entire system from the
 sources is nearly impossible and one has to use a prebuilt binary
 distribution. Another problem is that their source code is several
 millions of lines of code and thus it's impossible for a programmer to
 review the entire code; programmers can only focus on a part of the
 system. Finally, those systems are made with the use of many
 independant components (although some times programmers are forced to
 write something as a library because of the fact that there is no
 standard GUI in UNIX and since they can't master all toolkits, leave
 the frontend of their program to someone else). With this approach,
 libraries try to predict everything the user will need in a
 complicated API, that's both hard to learn and still not always
 sufficient, not to mention hard to test and a pain to maintain the
 backwards compatibility.

 Just like UNIX has a well defined "libc" that amongst other things
 provides the ability to read/write to the terminal, the Next Level
 should have a standard library to a GUI toolkit (this is almost 2010!).
 However, for one, standarizing a GUI toolkit is much harder. The C
 programming language is not good enough for this task and the systen
 would also have to standarize a higher level object model that makes
 using the GUI easier. However, standarizing a dynamic runtime system
 is even harder, because unlike C which was guided by the CPU opcodes,
 a dynamic language vm is much more vague and we cannot predict what we
 can expect from it, unless there are many programs that use it.

 pyvm is bootstrapping an experimental "Next Level System" where the
 dynamic language, the object model, script recompilation, graphical user
 interface, font engine, etc, are part of the core system. Application
 not only use it, but also give feeback for the ehnancement of these
 core components.

 Currently, pyvm is made of about 300 scripting files (python & pe)
 in 70k lines of code and 12k lines of mini C libraries. The base vm
 is written in about 30k lines of C. The fact that backwards
 compatibility can be broken does not mean that it is broken every
 day; the project is supposed to stabilize and the APIs properly
 documented.

 This all may sound great and all, but the fact is that it is not so
 great actually. What's presented above in this document is the theory
 of the project. In practice the reimplemented userspace programs are
 far from perfect and their main value the the extreme simplification
 of things. So it's supposed to interest people who believe that "being
 a user is boring" or want to play with a miniature of the existing
 userspace.

 A list of the various userspace prorgams that can be performed by pyvm
 can be seen in Doc/APP-LIST.txt

The rest
--------

Initial version of pyvm is Copyright (C) 2005-2009 Stelios Xanthakis

pyvm is distributed under the terms of the GNU GPL

pyvm uses code from various people.
Please see Doc/CREDITS.txt

Home page: http://students.ceid.upatras.gr/~sxanth/pyvm-2.0/
Git repo:  http://students.ceid.upatras.gr/~sxanth/pyvm.git
e-mail:    sxanth@ath.forthnet.gr (must contain the word "pyvm")