Leo Editor

If here are some Leo people reading here:

The "Screen Shots" link is broken.

It should be: https://www.leoeditor.com/screen-shots.html

But currently it points to nowhere.

I've used Leo extensively for one large project, several smaller ones and all the DD work for 8 years until 1/1/2017.

It's a very good and well thought out program, it's a bit like a cross between emacs org mode and python programming environment (rather than lisp) geared towards literate programming but very useful for other kinds of applications.

I'd love to see a 'Google docs' style multi-user version of it, that would be an awesome tool, especially if it would be self hosted.

I have been using it forever (over 10 years) to organize financial data and do taxes. While I should credit Python because these are Python programs after all, it is really Leo that enables me to easily keep data organized. Queries can be ran by easily running Python scripts inside of Leo with results directed to the log panel, turning Leo into a light-weight IDE.

For example the top node for accounting is like this:

  #@killcolor
  # accounting

  from datetime import date
  import pprint
  import math

  <<defs>>

  year = 2006

  <<2006>>

  inc_year()
  <<2007>>

  inc_year()
  <<2008>>

  ... more data

  inc_year()
  <<2018>>

  inc_year(0) #update certain yearly balance records without 
  advancing

  def runacct(argv):
      if len(argv) > 1:
        if argv[1] == 'q':
            transquery(argv[2].upper())
        elif argv[1] == 'g':
            groupquery(argv[2].upper())
        elif argv[1] == 'h':
            holdingquery(argv[2].upper())
        elif argv[1] == 'm':
            if len(argv) == 3:
                monthquery(int(argv[2]))
            else:
                monthquery(int(argv[2]), int(argv[3]))
        elif ... many other query options
      else:
        balancequery()

  if __name__ == '__main__':
      from sys import argv
      runacct(argv)

Ah yeah, Leo Editor. The Lotus Notes of the outliner-world. That thing is as powerful as horrible. So full of good ideas, and such a garbage in implementation.

On the good side stands the ability to have an programmable outline, paired with a good enough editor to handle the content of nodes. Then there also directives, which are basically special commands for inline-usage. Things like @wrap to wrap lines, or @language <value> to define activate language-specific handling for the following code. @language is especially useful because you can combine several in one node. Finally there is also the relativ open ability to customize things with python. All of this combined a regular workflow I still use with Leo is to create a node with several @language-blocks on a node. One for code, one for data, one for Documentation. Then call a selfmade-function which extracts the code and data and executes it and save the result in a new node in the outline. Very useful to transform or generate data on the fly. There are also directives to load/save external files, with support for some fileformats to automagically handle the outline.

But then again, on the bad side, as a dev I must say the whole projects has a horrible stench of foul code and ugly design. There is a huge amount of features which either work bad, don't work at all or even work in harmful ways (dataloss). The codebase is just a ragtag-compilation of random ideas from people which seems to have no clue about proper software development, and who are even proud to have come up with some shit they consider as smart. For anyone who wanna try out this software: don't except to much, and prepare for many hateful corners and a steep unnesseccary learning-curve. And save your data! Often.

People use Leo in different ways...

I used to use Leo for notes on everything I was working on. The killer feature for me was the tree outline pane could clone nodes. So I could have one subtree of say Projects, another of say my Jira tickets, a third on Talks and Blog Posts. And then have clones of the current ones all together in a subtree called Current. I would adjust their order each morning as my prioritised To Do list for the day.

More recently, I have tried switching to orgmode. Some aspects are great. But I really miss Leo's tree pane 'table of contents' and its clonable nodes.

I'm watching the videos and the nodes look like a powerful abstraction. I'm not a fan of some of the terminology, for example, "clones" are not really clones but the opposite: references

In case the author is reading this there is a broken link for "screen-shots", looks like a simple mistake of not including the root.

(because there is no toplevel comment saying this):

it is emacs' org mode on steroids. If you don't like org mode, move along.

...And some of the side effects of the steroids are already showing (e.g. "you can embed html in markdown". Really? So it is now an html renderer with markdown 'shortcuts'?)

Wish JetBrains would add these features to their IDEs. We need more literate programming today, not less.

I've tried Leo a couple of times and like the concept _a lot_, but never got on with the implementation.

past

https://hn.algolia.com/?query=Leo%20Editor&sort=byDate&dateR...