# organice: Org mode in a browser tab, without Emacs

> organice is a front-end only Org mode client that edits .org files stored in Dropbox, GitLab or WebDAV. It is aimed at people who already keep Org files and want to read or edit them from a phone. The trade-off is that it understands only part of Org syntax.

**200ok-ch/organice** — An implementation of Org mode without the dependency of Emacs - built for mobile and desktop browsers

- Repository: https://github.com/200ok-ch/organice
- Website: https://organice.200ok.ch/
- Stars: 2,671 · Forks: 169
- Language: JavaScript
- License: AGPL-3.0
- Published: 2026-09-28 · Updated: 2026-09-28 · Language: en
- Canonical page: https://hysenlabs.com/projects/200ok-ch-organice

## The gap organice fills: Org files away from the desktop

Org mode lives inside Emacs. That is fine at a desk and awkward everywhere else. The README states the project's purpose plainly: organice is an implementation of Org mode without the dependency of Emacs, built for mobile and desktop browsers. The stated audience is people who want to access or edit their Org mode files whilst on the go.

The design decision that follows from that is the interesting one. organice has no back end. It is a front-end application that talks to storage providers you already use: Dropbox, GitLab and WebDAV. The README says the maintainers run an instance at https://organice.200ok.ch that is open to anyone, that they store no data on their servers, and that they run no analytics there. Your files stay in your own account. That also means there is no server-side migration, no index, and no search across accounts: whatever the browser can fetch is what you get.

So the project is not trying to replace Emacs. It is trying to be the client you open when the laptop is closed and the file is already sitting in Dropbox.

## How organice reads and writes your .org files

The repository layout shows a React and Redux application built with Parcel. package.json lists react, react-redux, redux-thunk and redux-undo, plus peggy, a parser generator. The start and build scripts both begin with ./bin/compile_search_parser.sh, which suggests the search syntax is generated from a grammar before the bundle is produced. Storage adapters are visible in the dependency list: dropbox, webdav, and @bity/oauth2-auth-code-pkce for OAuth flows.

Because there is no server component, the data flow is browser to provider. You authenticate against Dropbox, GitLab or WebDAV, the app fetches the Org file as text, parses it into a Redux store, and writes it back when you save. redux-undo in the dependency list is consistent with the undo behaviour you would expect from an editor.

The parser is where the real constraint lives. The README's Current restrictions/expectations section says organice understands only a few in-buffer settings, and that other in-buffer settings are imported and re-exported but are not editable with organice. Read that carefully: unsupported settings are not dropped, but they are also not something the UI can help you change. If your workflow depends on configuration you cannot see in the app, you are editing blind.

## Installing organice as a PWA on iOS and Android

There is no package to install for end users. organice is a web application, and the README says you can use it from any browser. On mobile it can be added to the home screen, where it runs full-screen as a Progressive Web App with offline capabilities.

On iOS the README gives this procedure: open organice in Mobile Safari, tap the share button, and select Add to Home Screen. On Android the steps differ by browser. On Chrome, tap the menu button and select Add to homescreen; on Firefox, tap the menu button and select Install, or use the home icon with a plus sign next to the URL. The README notes that most browsers will then present a popup banner offering to add or install.

By default the app opens your root file directory. If you would rather land on one file, the README points to the file settings page, where you select it. That setting is the first thing worth changing, because a directory listing is a poor landing page on a phone.

## Running your own organice instance with docker-compose

Self-hosting is supported. The repository ships a multi-stage Dockerfile with a development target on port 3000 and a production target on port 5000, and a docker-compose.yml that wires both up behind profiles.

The compose file defines a dev service, a prod service, and an Apache WebDAV container for testing. Note the profile names, since the services do not start by default:

```yaml
services:
  organice-dev:
    build:
      context: .
      target: development
    ports:
      - '3000:3000'
    profiles:
      - dev

  organice:
    build:
      context: .
      target: production
    image: 'twohundredok/organice:latest'
    ports:
      - '5000:5000'
    profiles:
      - prod
```

The production service reads REACT_APP_WEBDAV_URL from the environment, and .env.sample lists the keys you need to fill in:

```bash
REACT_APP_DROPBOX_CLIENT_ID=your_dropbox_client_id
REACT_APP_GITLAB_CLIENT_ID=your_gitlab_client_id
REACT_APP_GITLAB_SECRET=your_gitlab_secret
REACT_APP_WEBDAV_URL=your_default_webdav_server_if_desired
```

If you build from source instead, package.json pins Node to ^20.17.0 and the start script runs the search parser build before Parcel:

```bash
yarn install
yarn start
```

That serves the app on port 3000. The Dockerfile also runs bin/transient_env_vars.sh during the build, so environment values are baked in at build time rather than read at runtime.

## Where organice stops: partial Org support and no back end

The honest limitation is syntax coverage, and the project says so itself. Only a few in-buffer settings are understood. Anything else is passed through untouched. For a file you own and edit in both Emacs and organice, that pass-through is usually acceptable. For a file whose behaviour depends on settings organice cannot edit, it is a trap: the app will not warn you, because from its point of view the content is simply text it does not interpret.

The second limitation follows from the architecture. With no back end, there is no server-side conflict resolution. Two devices editing the same file through Dropbox or WebDAV write to the same object, and whatever the provider does about concurrent writes is what you get. The README does not document a merge or conflict strategy, so treat simultaneous edits on two devices as unsupported until you have verified otherwise.

Offline support exists through the PWA, but the README does not document what happens when an offline edit is reconciled with a remote copy that changed in the meantime. If you need a guarantee there, organice is the wrong tool.

The third case is simply different: if you want a hosted task manager with accounts, sharing and notifications, organice provides none of that. It edits files. That is the whole product.

## organice compared with running Emacs itself

The obvious alternative is Emacs, which is the reference implementation and the thing organice deliberately does not depend on. The difference is not features, it is the deployment model. Emacs runs on a machine you control and gives you the full language, every in-buffer setting, agenda, export backends and the package ecosystem. organice runs in a browser tab and gives you a subset of the syntax plus whatever your storage provider offers.

Choosing between them is mostly about where the file lives and where you are standing. If you already carry an Emacs configuration you trust, running Emacs on a remote host and reaching it from a phone keeps full fidelity. organice trades that fidelity for zero setup: no server, no terminal, no configuration file, just a URL and an OAuth grant against a provider you already pay for or host. For a quick edit to a task list on a train, that trade is reasonable. For a system where the Org file is the source of truth for scheduling, it is not.

A third option worth naming is a plain text editor with WebDAV or Git sync. It gives you no Org awareness at all, which is worse than organice for structure but cannot mangle what it does not parse.

## Licence, maintenance and upgrade cost

organice is licensed AGPL-3.0. For anyone running the public instance or using it privately, that is unremarkable. It matters if you modify the code and expose it over a network: the AGPL's network clause is the reason some organisations keep AGPL software off their internal infrastructure. This is a description of the licence, not legal advice; check with your own counsel before deploying a modified build.

The repository is not archived, and the last push was on 2026-08-09. Releases are infrequent: 1.23 landed on 2026-01-07, and 1.22 and 1.21 both on 2025-05-06. The changelog.org file at the repository root is the place to look before upgrading, and the 1.23 release is titled Org Habits Consistency Graph, which tells you the kind of change that arrives between versions: a feature, not a compatibility break.

Upgrade cost for a self-hosted deployment is a rebuild, because the Dockerfile bakes environment variables at build time rather than reading them at container start. Changing REACT_APP_WEBDAV_URL means rebuilding the image, not restarting it. Budget for that in your deployment pipeline.

## Conclusion

Adopt organice if you already keep .org files in Dropbox, GitLab or WebDAV and want to edit them from a phone browser without installing Emacs. Do not adopt it if your files depend on Org features beyond the supported in-buffer settings, or if you need an offline-first editor that never talks to a storage provider. Before committing, open your real files in the interactive tutorial at https://organice.200ok.ch/sample and check that the syntax you rely on survives a round trip, and read the Current restrictions section of the documentation.

## FAQ

### What is organice and how is it different from Emacs Org mode?

organice is an implementation of Org mode that runs in mobile and desktop browsers without depending on Emacs. It is a front-end only application that syncs with Dropbox, GitLab and WebDAV, so it covers a subset of Org syntax rather than the full language.

### How do I install organice on my phone?

There is nothing to install from an app store. Open the organice web page in your mobile browser and add it to your home screen: on iOS, use the share button and Add to Home Screen; on Android, use the browser menu and choose Add to homescreen or Install. Started from the home screen it runs full-screen as a Progressive Web App.

### Which storage providers can organice sync with?

The README names Dropbox, GitLab and WebDAV. The .env.sample file lists REACT_APP_DROPBOX_CLIENT_ID, REACT_APP_GITLAB_CLIENT_ID, REACT_APP_GITLAB_SECRET and REACT_APP_WEBDAV_URL as the configuration keys for a self-hosted instance.

### Does organice support all Org mode syntax?

No. The documentation states that organice understands only a few in-buffer settings, and that other in-buffer settings are imported and re-exported but are not editable with organice.

### Can I self-host organice?

Yes. The repository includes a multi-stage Dockerfile and a docker-compose.yml with development and production services, using the profiles dev and prod and exposing ports 3000 and 5000 respectively.

## Sources

- [200ok-ch/organice on GitHub](https://github.com/200ok-ch/organice)
- [License: AGPL-3.0](https://github.com/200ok-ch/organice/blob/master/LICENSE)
- [Project website](https://organice.200ok.ch/)
- [README](https://github.com/200ok-ch/organice/blob/master/README.md)
- [Releases](https://github.com/200ok-ch/organice/releases)

---

Hysen Labs editorial analysis, written from the project's own repository and release notes. Cite the canonical page: https://hysenlabs.com/projects/200ok-ch-organice