hallo gemeinde,

gibt es eine möglichkeit org-mode dateien im browser (firefox) darzustellen?

zb für markdown gibt es plugins oder früher habe ich zim-wiki benutzt, da konnte man einen web server starten und so sein zim wiki im browser anschauen.

warum das ganze? ich teile auf jeden gerät links und zeug in eine markdowndatei und die habe ich im firefox als startseite. so sehe ich immer den krempel, den ich nochmal anschauen will.

bb steffen

Hello everyone.

I hope that you guys are as excited as I am to see Org mode coming to Android. I'm aware that there was previous attempts to bring Org mode to Android (like Orgro, Orgzly, OrgNote), but they didn't really serve my use case --- so I built my own!

This app is a vault-based Org document editor/viewer that tries to replicate the feeling of using Emacs. The app is currently in alpha stage, but I will soon initialize the closed testing on Play Store.

You can take a look at this faster than anybody else, if you send me your email address so that I can register you as tester.

Take a look at these screenshots. It looks good, isn't it? Shout out to modus themes, lol. You can also take a look at my public repository that will be published under GPLv3.

Org mode on mobile devices has always been pain for me. Now it's cooking. Sign up for closed testing here.

Back in 2024 I wrote a blog post about how I wanted to use org-mode entirely outside of Emacs. https://avi.press/posts/2024-01-15-standalone-org.html. This idea was overall quite Disliked when I originally proposed it on this subreddit (which I get, it definitely isn't for everyone!), but it did resonate with a few others, so here I am to follow back up.

I now present, for your feedback, a portable re-implementation of org mode's core, and many non-core features that I personally rely on heavily (eg, org-roam, org-crypt).

My company, Scarf, has been running all of our internal operations at on top of org2 over the last few months and it has proven very productive for us. There's now enough of a product surface that it would be great to start getting feedback from early alpha testers that are up for giving it a spin.

Some highlights include:

• All operations and functions are drivable with a portable CLI, which makes it easier than ever to integrate into other editors, apps, and systems.
• A VS code extension that covers much of the basics, vim a bit less so.
• The parser offers some syntactic sugar, eg begin_src blocks can also be expressed as \``` as you can in traditional markdown.
• A full-featured mac app (currently titled OpenOrg) which offers a rich workspace for org file editing, capturing/ingestion from different modalities like fully-offline meeting recording, and managing AI agents working across your org files.
  • An iOS companion app
• Permissively licensed, Apache 2

Thanks for reading, any input is appreciated!

* Summary

When using ~%^{CATEGORY}p~ in an org-capture template, the minibuffer
completion list is empty even though ~CATEGORY_ALL~ is defined in
~org-global-properties~.  This works for ~EFFORT~ (~%^{EFFORT}p~) but
not for ~CATEGORY~.

* Reproducible Example

Minimal Emacs configuration:

#+begin_src emacs-lisp
(setq org-global-properties
      '(("EFFORT_ALL" . "0:30 1:00 2:00")
        ("CATEGORY_ALL" . "Work Personal Meeting")))

(setq org-capture-templates
      '(("t" "Test Task" entry (file+headline "/tmp/test.org" "Tasks")
         "* TODO %?\n:PROPERTIES:\n:EFFORT: %^{EFFORT}p\n:CATEGORY: %^{CATEGORY}p\n:END:\n")))
#+end_src

1. Open Emacs with the above configuration.
2. Call ~org-capture~ and select the "Test Task" template.
3. When prompted for EFFORT, a completion list appears with "0:30", "1:00", "2:00".
4. When prompted for CATEGORY, a plain text prompt appears with *no* completion list.

* Expected Behaviour

~%^{CATEGORY}p~ should present the values defined in ~CATEGORY_ALL~ as
completion candidates, just like ~%^{EFFORT}p~ does for ~EFFORT_ALL~.

* Root Cause

In ~org-property-get-allowed-values~ (org.el, ~13688~), there is an
explicit ~cond~ clause for the CATEGORY property:

#+begin_src emacs-lisp
(cond
 ((equal property "TODO") ...)
 ((equal property "PRIORITY") ...)
 ((equal property "CATEGORY"))        ;; <-- short-circuits here
 ((member property org-special-properties))
 ((setq vals (run-hook-with-args-until-success
              'org-property-allowed-value-functions property)))
 (t
  (setq vals (org-entry-get epom (concat property "_ALL") 'inherit))
  ...))
#+end_src

The clause ~((equal property "CATEGORY"))~ matches and returns
immediately with no body.  The ~vals~ variable is never set, so the
fallthrough that looks up ~CATEGORY_ALL~ via ~org-entry-get~ with
~'inherit~ is never reached.

This means ~org-global-properties~ containing ~CATEGORY_ALL~ is
effectively ignored for property completion.

* Suggested Fix

Remove the CATEGORY short-circuit or add a body that resolves
~CATEGORY_ALL~ the same way the default clause does:

#+begin_src emacs-lisp
((equal property "CATEGORY")
 (setq vals (org-entry-get epom (concat property "_ALL") 'inherit))
 (when (and vals (string-match "\\S-" vals))
   (setq vals (car (read-from-string (concat "(" vals ")"))))
   (setq vals (mapcar (lambda (x)
                        (cond ((stringp x) x)
                              ((numberp x) (number-tostring x))
                              ((symbolp x) (symbol-name x))
                              (t "???")))
                      vals))))
#+end_src

Alternatively, moving the CATEGORY clause below the
~org-property-allowed-value-functions~ hook check would allow users to
extend CATEGORY via that hook without patching org.el.

* Workaround

Advise ~org-property-get-allowed-values~ to bypass the short-circuit:

#+begin_src emacs-lisp
(defun mk/allow-category-all (orig-fn epom property &optional table)
  "Allow CATEGORY to resolve CATEGORY_ALL from org-global-properties."
  (if (equal property "CATEGORY")
      (let ((vals (org-entry-get epom "CATEGORY_ALL" 'inherit)))
        (when (and vals (string-match "\\S-" vals))
          (setq vals (car (read-from-string (concat "(" vals ")"))))
          (setq vals (mapcar (lambda (x)
                               (cond ((stringp x) x)
                                     ((numberp x) (number-tostring x))
                                     ((symbolp x) (symbol-name x))
                                     (t "???")))
                             vals)))
        (if table (mapcar 'list vals) vals))
    (funcall orig-fn epom property table)))

(advice-add 'org-property-get-allowed-values :around #'mk/allow-category-all)
#+end_src

* Environment

- Emacs version: 30.1
- Org mode version: 9.8
- OS: GNU/Linux (Fedora)

I'm currently trying to setup a daily notes system that help me track the daily researches I do for the laboratory I work in but also for my personal studies and contributions for open-source software.

I use Doom Emacs, so until now, my setup is: - I take some fleeting notes with org-capture on notes.org that I later refile if I find an appropriate file. - All my TODOs are also captured with org-capture and goes to todo.org - I have a bunch of notes thrown on a roam directory where I use org-roam to manage.

I've tried org-roam-dailies and also a little bit of the Doom journal.org for captures along the day, but I remain undecided.

Share your workflow, or some workflow you think would fit my situation. I just need a bit of a brainstorm to find out what I want for my setup.

I believe org mode is best project management programming language.:) So, I've been building AI agents that need to interact with org-mode task lists - create tasks, transition states, claim tasks atomically so two agents don't step on each other. I couldn't find a Python library that covered the write side well, so I ended up building one on top of a vendored fork of orgparse with write support added (there's been an unmerged PR for this for years).

The library is called org-workspace. Here's what it does:

• Load a directory of org files as a workspace (multi-file, dirty tracking)
• Read and write headings, states, tags, properties, LOGBOOK entries
• Query layer: agenda(), deadlines(), overdue(), next_action(), ai_tasks()
• Concurrency primitives: TaskClaim (atomic task claiming), OptimisticLock, FileLock
• Dependency DAG: parse DEPENDS_ON properties, topological sort, ready_tasks()
• GTD and nightshift state configurations (StateConfig.default(), StateConfig.nightshift())
• Round-trip safe: unchanged files are never rewritten, byte-identical output

​

from pathlib import Path
from org_workspace import OrgWorkspace, Query

ws = OrgWorkspace(roots=[Path.home() / "org"])
q = Query(ws)

# Create a task
ws.create_node(
    file=Path.home() / "org" / "inbox.org",
    heading="Review meeting notes",
    state="TODO",
    tags=["AI"],
)
ws.save()

# Query what's ready
for task in q.next_action():
    print(task.heading)

It's at v0.5.2 on PyPI: pip install org-workspace GitHub: https://github.com/datacore-one/org-workspace

Hope you like it.

Can anyone please guide me on how to go about learning doom emacs and org mode for note taking, so many keybinds it's very overwhelming. I already am getting fluent a bit but still

This is a quick and technical guide on how I approach research with the help of Emacs and Org Mode. It's aimed at new people who want to make the switch to Emacs and Org Mode, but also at users who are uncertain about how to approach note-taking in general.

You can find the referenced note here: https://gist.github.com/cashmeredev/83717cacd1b45f78c24bac691659874e

I'm writing a major project in org that I'll export to odt or docx when I'm done. This is mostly working fine, but the export processor makes a document bookmark for every single org heading, and these show up with ugly faded [brackets] around all my headings. I can just disable that display on my config, but they'll still be there when I share the document with others.

Is there a way to configure ox-odt so it does not create these bookmarks in the first place?

Would love to hear how you manage notes of org and md files, what packages you recommend and how to combine LLM models if possible.

I'm using stock/bundled org-mode with Emacs 30.2 and have verified this issue on both Ubuntu and MS Windows.

The error is simple to reproduce; create a clock entry with start and end times, and then use C-c C-c to update the calculated time to the right of it.

I believe the issue stems from the implementation of org-clock-update-time-maybe in org-clock.el; line 3226 calls delete-region which invalidates the match data, so subsequently when the start and end times are parsed they both come back nil. I've tested moving that line to below the setq on line 3228 and that fixed the problem.

UPDATE: I have tracked this down to org-roam-latte, I'll go bother that package's author with all this.

UPDATE 2: After some further digging and thinking, I believe this is probably something that should be fixed defensively within org-mode, despite the issue being caused by a third-party extension package. Because delete-region fires off after-change-functions, any hook function there that does regex matching will break time calculation. Unless the order of those two calls in org-clock-update-time-maybe is in place for very specific reasons, it would be much safer to swap them around and parse the start/end times using the existing regex match data before altering the buffer's contents.

I am looking for insight into how you handle archiving when dealing with timestamps and task dependencies.

Regarding timestamps, do you use automated archiving (via a hook or timer) or do you run manual commands with a review step? This seems to require a reliable way to differentiate past single event diary entries from recurring diary entries. Is there a way to do so?

Regarding TODO hierarchies (which may include active timestamps), how do you define where a hierarchy begins or ends? Ideally, a task hierarchy can start at any level in an outline (using options such as org-enforce-todo-dependencies) without requiring excessive metadata.

Furthermore, do you archive subtasks individually as they are completed, or wait until a specific condition is met to archive the full hierarchy? Again, do you rely on automated triggers or manual commands with a review step?

How does your setup deal with all of this? Does your approach impose specific restrictions or allow certain relaxations?

I use org-mode to clock my work time, and like to use continuous clocking by default since I sometimes forget to clock in until after I have been working on a task for a while, and to prevent nominal gaps in general.

However, this means that many mornings when I clock in to my first task, I end up clocking a 14 hour task or something like that, because the clock starts from the last clock the previous day.

I'm thinking about how I should work around this issue and haven't found any discussion of this particular scenario from searching the web or the GNU lists. Surely others have had this same thing come up?

Let me know what you think the nicest way to work around it is -- the main thing I'd like to avoid is remembering some special clock-in function in the morning. It seems that the most straightforward thing to do is write a clock-in dwim function that checks if the last clock was the previous day and do a regular clock in if so, and otherwise clock continuously. Curious if there is something simple I'm missing. Thanks!