What makes Leo special?

Leo's outlines add a new dimension to programming
Leo shows you your code, your data the way you want
Leo extends, completes and simplifies literate programming
Leo is extensible and dynamic

Leo's outlines add a new dimension to programming

Leo organizes all aspects of code or data into a visual outline. But outlines do more than merely organize:

- Outline structure is first class data that can be used by programs or scripts. All aspects of Leo are fully scriptable using Python scripts embedded in outlines. In particular, scripts have easy access to the data within outlines, including all the hierarchical relationships explicitly created by outlines.

- Outline nodes provide a natural way of associating meta-data (descriptions of data) with the data themselves. Headlines contain descriptions; body text contain the actual data. Meta-data is useful to humans as summaries. More importantly, it is easy to write scripts driven by meta-data.

-  Leo can generate scripts from outlines using the standard markup language called noweb. In other words, scripts not only use outline structure, scripts have outline structure.

- One of Leo's plugins creates "script buttons" from special "script nodes" in an outline. Script buttons appear in an extensible part of Leo's outline window. Script buttons execute the script in the script node on the presently selected outline node. That is, script buttons bring scripts to data.  You have no idea how cool this is until you try it. For example, one script button automatically creates unit tests from scripts in the selected outline without the programmer having to create unit test classes!

There are too many implications to describe here:  integrating outline structure with programming is a fundamental addition to the programming world. The result is an immensely powerful scripting and programming environment.

Leo shows you your code, your data the way you want

Leo's outlines provide a way of generating arbitrarily many views of an outline within the outline itself. Users create views with special linking nodes called clones. Leo updates cloned outlines simultaneously: any change (in content or structure) made to one clone instantly changes all other clones.

Views are explicit and permanent; they are a powerful tool for understanding and managing any kind of complex data. For example, views often represent tasks. Programmers use task views to gather code, notes, test runs and any other data that is relevant to a programming task. Managers use task views to gather design notes or to-do lists. Web designers use views to gather parts of a web site that are of interest.

Leo extends, completes and simplifies literate programming

Leo's users can generate arbitrarily many files, called derived files from a single outline. This process is called "tangling" and is controlled by the noweb markup language. Untangling is the reverse process, viz., updating a Leo outline from changes made to derived files. Tangling and untangling happen automatically, so one quickly learns to regard typical source files as something uninteresting, much as a C programmer would regard machine language files.

Tangling is the key feature of so-called literate programming (LP) systems.  LP has been around for a long time. It never caught on because LP tools were hard to use and because LP programs were hard to understand. Leo changes all that. For the first time, LP becomes easy to use.

Leo is extensible and dynamic 

Leo has an active community of users; Leo is typically one of the top 200 SourceForge projects. People invent new uses for Leo almost every week. Thousands of people use Leo; many are wildly enthusiastic.

Leo's users contribute greatly to Leo's development.  For example, Leo has a simple, powerful plugin mechanism that takes full advantage of Python's dynamic character. This plugin architecture was created by one of Leo's users, Paul Paterson. Paul has recently written another plugin that manages the dozens of plugins that Leo's users have contributed.