Org tutorials

> As of 2025-02, there is no formal Org-mode syntax definition.

is very far away from perfection

> Orgmode got me through college, research, and at work, it really is the perfected markup language that can do a lot more than just being a markup language. The extensibility and out of the box export to other formats makes it immediately useful for at least 80% of common tasks.

With regards to your 80% claim, do you happen to know an extension that works well with pasting images from clipboard?

Over the years, my professional note taking has become extremely reliant on quickly pasting images (most often screenshots from papers or quick-and-dirty plots I made myself) from clipboard directly into the notes. The friction of doing this in vanilla org-mode is the only reason I'm not doing everything in org-mode.

I have on gripe, that is the mixture between org structure and org document heradings. I know, they are the same, and such a distinction doesn't exist.

You can start a "document" at any place in the org hierachy. I would rather prefer a distintion between these two concepts.

orgmode is what helped me write my first self-published novella, without having to worry too much about formatting for print. Apart from the initial configuration, it was pretty much plug and play when going from plain text to something I could upload to KDP.

> if orgmode is so good, has it not been implemented outside of emacs

Org Mode is that good, but part of its goodness is due to being in Emacs.

Emacs is not really an editor: it’s an easily user-extensible operating environment with a remarkably shallow learning curve (seriously: one can go years just setting variables before moving up to simple functions and then starting to explore). Having all that power so easily accessible is a part of what makes Org Mode great. It’s what means that each Org Mode user can mold his experience to his needs.

I've written a handful iOS apps powered by org. Journelly is my latest https://xenodium.com/journelly-like-tweeting-but-for-your-ey...

I got quite a few users who either come from Markdown or simply don't care about the internal implementation. Here's a wonderful writeup by a user https://ellanew.com/ptpl/157-2025-05-19-journelly-is-org-for...

ps. Markdown is also coming to Journelly https://xenodium.com/markdown-is-coming-to-journelly

edit: My other org-based iOS apps

- Flat Habits (habits tracker): https://flathabits.com

- Plain Org (general purpose org viewer/editor): https://plainorg.com

- Scratch (a scratch buffer): https://apps.apple.com/us/app/scratch/id1671420139

There is an implementation for neovim, and some "viewer" applicatrions for android, etc:

https://orgmode.org/tools.html

Basics are easy to replicate, but one of the reasons why org is so useful is because it is tied into the emacs ecosystem, so you can write extensions/configuration tweaks in lisp. You can hookup agenda (calendars), etc, etc, and those things don't really translate so well to external tools.

If you had to write a lisp interpreter, and fake "bare minimum" compatability? At that point you'd be better off just running emacs for real.

The biggest strength is not the file format or basically the org mode markdown flavor. The strength comes from integrating it with all the other Emacs stuff. Org-babel for example, think of it as a suped up Jupyter notebook. And it integrates with the emacs calendar/agenda. The closest you can get is maybe Obsidian's Dataview plugin, but it absolutely pales in comparison to Emacs Org.

It is one of THE main reasons for me to use Emacs.

I think it's kind of the other way around.

Emacs is a universal lisp environment, and org-mode is a lightweight markup language that works well with it.

You can port the markup language, but it's a heavy lift to port the lisp way of thinking to another language.

Standalone orgmode implementation is called emacs with org mode. I'm that person that uses emacs solely for orgmode and write code in other editors (vscode/zed/cursor), we also exist

Like someone else mentioned in this thread, I'm not a "traditional" Emacs user. I use Emacs only for Org Mode; for the rest I use Vim, or occasionally something else. (For the rest of your question, there are some good responses from others.)

There is an orgmode for VS Code that I used for a while:

https://github.com/vscode-org-mode/vscode-org-mode

The reason is that elisp org-mode is huge and re-implementing it without elisp is a great undertaking.

I started an implementation in javascript that I integrated in an obsidian plugin [0]. But the plugin has a long way to go before reaching feature parity with emacs orgmode.

[0] https://github.com/BBazard/obsidian-orgmode-cm6

Orgmode isn't really just a MD equivalent. It's the integration into Emacs and the entire platform that makes it so incredible and powerful. I would love an alternative because as TS developer I don't use Emacs anymore (non VSCode LSP is a nightmare to run) but it just doesn't exist :(

1. it has, there's various mobile apps and a reimplementation for vim and vscode at least

2. it's very very good and having access to it is enough reason for some people to become emacs users, much like magit

orgzly revived for android is pretty great.

more tooling would be good though, especially command line tools to get data in and out.

What would be the point? Without emacs all you're left with is another markup language.

After a few attempts over the years to move to emacs -- all them failures -- what finally got me to use it consistently was Org. The funny thing is I still don't use it for coding or other writing; emacs is on my computer as the org platform.

I am VERY interested in Obsidian, which seems like it could definitely support an org-like system. It's _almost_ there as far as my own use cases are concerned, and the seamless sync to mobile is really enticing.

But goddammit, my fingers now know how to move through org buffers pretty well, and Obsidian lags on that front, so I may be stuck. ;)

Check out Org-Roam: https://www.orgroam.com/

It has some Obsidian-like features inside Org Mode.

So, if you're looking for an easier-to-use UI, it's not it, but if you're looking for Obsidian-like linking and backlinking, it has that.

Logseq has buggy syncing and imposes some odd constraints on your files if you want to keep it easy to edit the same file from both Logseq and Emacs, but in principle, it's all there!

Not sure if it can execute code blocks tho.

What specific features / functions are most compelling for lists? Of course moving a tree around with different header levels. But anything specifically great with lists?

I try it regularly and I was running an org-mode based task management for a year and some months in between, but man, I do not have time and patience for sync conflicts in 2025. It can work but I have to be very cautious, and iCloud sync being a bit mysterious does not help. But I've also recognized that I don't have very complex projects, that GTD tools do not matter since their contents are transient by nature and that Apple Reminders is basically good enough. As a bonus it allows me to share Lists/Projects with my wife.

Org mode offers so much more than just syntax. You can use org files as a calendar, a todo/issue tracker with time accounting, a diary/knowledge base (zettelkasten, org-roam), as a literate programming tool (think jupyter code notebooks but for practically any programming language with org-babel), or a publishing tool (static site generator, latex/pdf export) all at the same time.

To be quite frank, Org mode is a lifestyle which existed long before Notion or Obsidian did. Saying that it has a barrier to entry is a bit of an understatement.

Having said all that, quite ironically, I've migrated over to Obsidian because I started using Intellij more for work, meaning that I don't need Emacs for its other capabilities all that much.

Markdown is a markup tool, i.e. you decorate your text. Orgmode on the other hand is a complete toolbox where you can add tags to notes, filter on these tags, manage calendars, etc. You can enter tables both for formatting and spreadsheet like calculation.

And you can insert snippets of code into your notes, like

    #+BEGIN_SRC shell
       ls | wc -l
      find . -type f -name "*foo*" 
    #+END_SRC

You can even augment orgmode with elisp code if you are so inclined.

`org-mode` used with Emacs is the tinkerer's dream playgound. Apart from the basic markdown stuff, there are so many wild things you can do. For example, org code blocks are not just the basic markdown code blocks that show formatted code. Org code blocks can actually be executed and can show the output of the code, inline. So you can write code blocks (that may include data found in variables/tables/etc elsewhere in the org file), then "refresh" your org file and all the inline outputs of the code blocks will be updated.

Besides being a markup for structured text with special syntax for links/tables/math, here are my highlights that I use:

1. Code blocks that can be executed have their result captured

2. Links to everything

3. Drawing vector images (SVG) with a tablet

4. Perform calculations on tabular data (like a simple Excel sheet)

5. Agenda (connected to Google Calendar)

6. Spaced repetition system for language learning

7. LaTeX export for reports/presentations with citations

Expanding:

1.1. Execute code on different remote machines

1.2. Work with sessions and execute code asynchronously

1.3. Use noweb syntax for reusing code blocks

1.4. Tangle ("export") source blocks to files (locally or in a remote machine!)

1.5. Use a source block to generate a graph/plot and view the figure in the same place

1.6. Use narrow functionalities to automate script executions (example: execute all blocks in this section).

2.1. Links to PDF pages, commits/pr`s/branches, email, other files` particular lines, remote files, web pages, etc.

7.1. Very easy to select which sections I want to export or not

7.2. Include hand-drawn SVG graphics in the PDF output

7.3. Generate Beamer presentations

First of all "emacs" rather than "eMacs".

But to answer your main question, markdown is used for writing text which can then be converted to HTML, PDF, etc, etc. It's used just to format things. org can be used in that way, and it might feel better/worse depending on what you feel about the choices used for various formatting styles.

However the big gain of org is that you can use it to format dynamic tables, handle todo-lists, have deadlines, recurring tasks, etc, etc. It makes no sense to compare org-files with markdown-files. It's like saying "I use notepad how does Excel help you do more?" - they do different thigns.

Now, much like excel, most people don't do everythign with org, but they can if they want to. It is extraordinarily flexible, and can be extended with custom lisp code if necessary.

I track rental properties with an org-document for each property, and I get per-year profit/loss statements in a neat format with graphs too. You can't do that with markdown.

Markdown is just a markup-language, while orgmode is a tool-collection with a community of its own, which happens to also come with its own markup-language. That's not the same, and comparing them on that level makes little sense.

> Genuinely curious because I tried at some point and it felt too heavy.

Which part felt heavy? The syntax? The tooling? The setup? orgmode's purpose is to deliver an environment for managing your notes, tasks, data, etc. Of course, will it be more heavy than just the markup-language alone, as most documentation focuses on the tooling and which jobs you can execute with it. This more akin to a whole Office-suit, than a simple plaintext-editor.

Orgmode has standardized primitives for the things which exist in some markdown note taking implementations but differ from implementation to implementation.

Markdown doesn't have a built in concept of todo or tag or scheduled event, for instance. It wasn't built for that.

I hate emacs but orgmode is still the file format which contains all of the primitives I need for my notes which looks like it will have the most staying power. I hope to be able to edit the same files in 2035 using whatever brain-connection device everybody is using in the future that I used in 2015 running on a netbook with 1GB of RAM.

Markdown files from the note taking flavor of today will have to be migrated somehow.

I don't use it anymore but org-babel allows you to execute commands in code blocks. I would use that to build interactive explorations when learning how APIs work for example. I didn't find that nearly as seamless with Markdown.

Combined with org-agenda you also unlock a calendar with recurring events, task priorities and more.

Hyperbole is the weirdest thing ever (in a good way), I can't exactly describe it to people either because it's a monolithic package that is made up of a number of packages (like the one for window control) but once you start using it and adopting it gradually you reach an epiphany. At that point the usefulness of Hyperbole is evident but until then nada, it seems more hassle than it's worth (though there are moments when it has bugs relating to other packages, like org, but those are quickly fixed by the maintainers in my experience).

Though a downside is that you end up curating a workflow that is so tailored to you that it seems weird from the outside, if it ever leaks, i.e. weird notation in git commit messages. That's due to sprinkling implicit and explicit "buttons" (pieces of text roughtly) throughout text (source code or otherwise).

I think a hurdle one has to make to adopt Emacs is to stop expecting things to work as you might have come to expect them from other programmes. Sometimes this is for historical reasons, but the main reason is that Emacs just has it's own logic, which may seem counterintuitive at first but often has very good reasons behind it. Try to persist past through that final 10% and you may find there are reasons why they're as they are. And when you need help use the channels out there...

Try asking your favorite LLM.

ChatGPT4o has been a godsend for adding helpful snippets of Elisp to my own ~/.emacs file.

Syncthing, maybe?

Yes! I experimented with it on my EXWM setup. After some back and forth via Aider, it made me a module to help me control and monitor tasks on my timewarrior setup, giving me a pomodoro-like indicator on my taskbar (changing colors as it approaches one hour).

It was a cool experience! I had it evaluate the code via commands to the emacs daemon, without reloading EXWM (ballsy, but I was prepared for failure).

EXWM is extremely flexible, but there is a high barrier of entry to using and customizing it. Having an LLM embedded to a live-evaluate desktop environment makes the interface more approachable without reducing its flexibility as much.

It also allows you to create explicit controls that map to the user’s muscle memory and sub-symbolic sensing of the environment, while staying out of the way during normal usage — a different paradigm than embedding an agent as an interface in its own right to control the environment (via speech or text).

Since open source software is readily modifiable, maybe soon it will unironically be the year of the linux desktop.

What lead you to choose that over say obsidian, notion, Joplin, and the many others that pretty much do the same thing?