
GnuCash currently consists of six (mostly) independent modules:

The Engine
----------
"The Engine" (src/engine) provides an interface for accounts and transactions.
An account consists of an account name, a default currency, a stock-ticker symbol
(if applicable), notes, some miscellany and a list of "split" transactions.
A transaction consists of a list of splits, with each split having a description
and memo field, date entered and date reconciled fields,  quantity and
price fields (price == 1.0 for plain old bank accts), and some misc disposition
fields.

The current implementation is file-format (not SQL) based.   It defines a byte 
stream, for saving to a file or transmitting via pipes/sockets ("persistence"
and "data migration" -- the byte stream allows the engine objects to be 
moved/copied/dynamically recreated on any host. ).  The API also 
provides simple concurrency controls, including a session object, and 
primitives for beginning/committing/rejecting edits.  This should be enough to 
allow SQL-based transactional back ends to be implemented.   The GUI uses
and respects these primitives, so GnuCash as a whole should "just work" with
an SQL back end.

The engine code contains no GUI code whatsoever, and is essentially OS-neutral.
(It might even compile & run under DOS!)


The Register
------------
"The Register" (src/register) implements a ledger-like GUI that allows the user
to dynamically enter dates, prices, memos descriptions, etc. in a natural,
intuitive fashion that should be obvious to anyone who's used a checkbook
register.  The code is highly configurable, allowing the ledger columns and
rows to be laid out in any way, with no restrictions on the function, type
and number of columns/rows.  For example, one can define a ledger with
three date fields, one price field, and four memo fields in a straightforward
fashion.  Cell handling objects support and automatically validate date
entry, memo entry (w/auto-completion), prices, combo-boxes (pull-down menus),
multi-state check-boxes.  Cells can be marked read-write, or output-only. 
Cells can be assigned unique colors.  The currently active ledger row-block
can be highlighted with a unique color. 

The register code is mostly GUI-independent; i.e. the motif/gtk/qt code is
confined to two files and a small number of lines of code.   The Motif version
is the best one currently, the gtk code works, but the underlying gtk table
widget is not really powerful enough to provide an elegant interface.

The register code is completely independent of the engine code, knows nothing
about accounting or any of the other GnuCash subsystems.  It can be used
in independent projects that have nothing to do with accounting.

Reports
-------
"Reports" (src/reports) is a perl/html based system to create balance sheets,
profit & loss statements, etc. by using the engine API's to fetch and display
data.  Very alpha code, under development.

Quotes
------
"Quotes" (src/quotes) is a perl system to fetch stock price data off the net
and jam it into the GnuCash engine API.  Very alpha, under development.

Scheme
------
"The Scheme" (src/scm, src/guile, src/prefs) is a scheme based infrastructure 
meant to provide general extensibility, as well as command-line/resource file
processing, user-preferences state management,  & other functions.  Very alpha,
under development.

GnuCash
-------
"GnuCash" (src/motif, src/gnome, src/qt) is the main GUI application.  It
consists of a collection of miscellaneous GUI code to glue together all of the
pieces above into a coherent, point-and-click whole.   It is meant to be
easy to use and intuitive to the novice user without sacrificing the power
and flexibility that a professional might expect.    When people say that
GnuCash is trying to be a "Quicken/MSMoney look/work/act-alike", this is 
the piece that they are referring to.  It really is meant to be a personal-finance
manager with enough power for the power user and the ease of use for the beginner.

Currently, the Motif interface is the only operational interface.   The gtk 
code compiles, but most of the functions are not wired in.  The Qt code won't 
compile, most-all functions are missing.



