Six exercises, in order. By the end you'll have linked notes, a working agenda, a table in the database, and a keyboard shortcut you wrote yourself.
Press open… at the top of the file tree and choose a folder — an empty one is perfect for now. This is your workspace. Everything you make lives here as an ordinary file, and you can move or back up the folder at any time without telling EEditor.
Now press ⌘⇧N and call the new note index.md. Type a couple of lines.
Stop typing, and it saves itself.
In index.md, type:
Reading list: [[
As soon as you type [[ a list of notes appears. There's only one so far, so
finish the link by hand — [[reading]] — and close the brackets.
Press ⌘⇧N again and create reading.md. Write a line or two, then press
⌘P and jump back to index.md by typing idx — quick open
matches fragments, not prefixes.
Press ⌘E to preview, and click your [[reading]] link. You land in the
other note, and under the editor a bar now reads ↩ 1 backlink: index.md. Nothing
built that index; it's derived from the files every time.
Add #tutorial somewhere in each note. The tags panel picks it up;
clicking it searches for everything carrying that tag.
In the agenda box in the sidebar, type this and press ↵:
call Bob tomorrow !!
You get an item due tomorrow at high priority — the date and the !! were parsed
out of the sentence. Click the item to open its editor and give it a note, or a recurrence of
every 2 weeks.
Add two or three more, then press calendar. Drag one to a different day. That's the reschedule; there is no save button.
Open setup in the agenda panel. Define a category — call it
work/calls — and a rule that catches anything mentioning a phone call:
(defrule calls
:when (str-matches text "call|phone|ring")
:assign "work/calls")
Press apply. Your call Bob item is now filed under
work/calls without you having categorised anything by hand. Add ten more items
and they file themselves too.
This is the Lotus Agenda idea EEditor is built around: you write in whatever words you
think in, and the structure is applied afterwards by rules you can change at any time.
Categories are hierarchical, so work/calls automatically belongs to
work.
Press ⌘J for the REPL. Start with arithmetic, then move on:
λ (+ 1 2)
3
λ (map (fn (x) (* x x)) (range 1 6))
(1 4 9 16 25)
λ (str-join ", " (list "one" "two" "three"))
"one, two, three"Now make a table. This is a real SQLite table underneath:
λ (deftable books (title:string author:string year:number))
λ (insert books {:title "The Mythical Man-Month" :author "Brooks" :year 1975})
λ (insert books {:title "Thinking Forth" :author "Brodie" :year 1984})
λ (browse books)
browse gives you a table widget, not a wall of text — click through it. Try
(edit books 1) for a form with working fields.
Ask a question of it:
λ (query books :where "year < ?" :params (list 1980) :order "year")
Press snippets to load the standard bundle, and a hundred and fifty more
functions become available — (zzromanos 2026), (timeat "tokyo" "now"),
(zzconverte 100 :c :f). The whole language is documented at
eelisp.app.
One more thing: select some EELisp in a note — or put the caret in a fenced eelisp
block — and press ⌘⇧↵. The note just became a notebook.
Press ⌘⇧K. EEditor writes the default keybindings into
.eeditor/keybindings.eelisp and opens it. Read the top of the file — that's the
whole language.
Add a binding of your own at the bottom:
(bind "Mod-Shift-t" (ed-insert "- [ ] "))Save with ⌘S. Go to any note and press ⌘⇧T — a task line. No restart, no preferences pane.
Now one that computes:
(bind "Mod-Shift-b" (ed-insert (str "[[" *date* "]]")))That inserts a wiki link to today's daily note, whatever today happens to be. The date, the caret position, the selection and the whole buffer are all available to your code — see the binding reference for the full list.
Finally, decide where you land when EEditor opens. Add one line:
(on-start (ed-cmd "daily-note"))
Now every launch drops you straight into today's note, created if it doesn't exist. Prefer a
fixed dashboard? (on-start (ed-open "index.md")). Prefer nothing at all?
(on-start).
Right-click the workspace row in the file tree and choose New form…. Call it
Notes. An empty window appears on a canvas, with a toolbox on the left and a
properties panel on the right.
Click Text box in the toolbox, then click near the top of the form. Click
Button, then click below the box. Two controls, named txt1 and
btn1. Pick the button and change its Text to Add.
Now double-click the button. EEditor names its handler, writes an empty one at the end of the
file, and opens the code with the caret on it. Notice the top of the file: the layout you just
drew is a (form …), and it is EELisp like everything else. Make the handler do
something:
(deftable notes (text:string))
(defn btn1-click (f)
(insert notes {:text (ui-get f "txt1")})
(ui-set "txt1" :value "")
(ui-message (str (count-records notes) " notes")))
Press ▶ run. Type something, press Add. The row is in the
database — (browse notes) in the REPL shows it — and the toast counts them.
■ stop takes you back to the designer.
One more thing. In the REPL, type (ed-form "Notes"). The form opens in a
floating window over whatever note you are writing, and stays there. Bind that to a key and
you have a tool. Chapter 10 of the manual has the rest: grids
with sorting and pages, validation, menus, tabs.
To see what a finished one looks like, download one of the example forms — a record-at-a-time book catalogue, a browser for every function in the language, the agenda with tabs — into your workspace, run it, and read its code.
And the thing worth doing on your own: open your keybindings file and delete a binding you don't like. That key goes straight back to the editor's normal behaviour. The configuration is the whole story — there's nothing underneath it you can't see.