I am working on a project https://github.com/org-rs/org-rs written in Rust programming language. The goal of the project is to provide a parser for the Org markup language.

Because of the incompleteness of Org's spec, I have to study the original implementation of the parser that is written in Emacs Lisp. https://code.orgmode.org/bzg/org-mode/src/master/lisp/org-element.el (Emacs and Orgmode are licensed under GPLv3)

In order to provide the complete implementation of the parser I am using the same parsing algorithm as original implementation.

The problem I am facing is that the Rust ecosystem is primarily licensed under permissive licenses (MIT and Apache2) and this presents a problem for my project. Since my project technically is a library licensing it under GPL severely impacts adoption of my library - other projects will have to become GPLv3 too in order to include my library. (Rust statically links libraries)

Am I legally obligated to release my work under the GPLv3 license? Or can I use MIT/Apache2/LGPL license to release my work? This is a question of life and death for my project. If I have to use GPL - my project is going to be still-born and I would rather not waste my time on it.


Your code either is derivative of GPLv3 software, or it is not. If it is derivative you can only publish your code under the GPLv3 as well, if it isn't derivative you can do whatever you want.

It is not entirely clear whether your software would be derivative of the Emacs Orgmode implementation.

  • Implementing the same file format does not render your software derivative.
  • Looking at some details in the original implementation would might not render your software derivative.
  • In contrast: porting/translating the entire parser would clearly be derivative.

I would suggest to avoid looking at the Emacs Orgmode code. Instead, reverse-engineer the necessary behaviour. Do implement stuff that's in the manual or other documentation. Do run Emacs to test actual behaviour. If an incompatibility turns up in the future, treat it as a bug and fix it.

You will likely get a good approximation of the Orgmode language with only a tiny subset of its features – most of Org complexity is around its dynamic features, e.g. when used as an interactive notebook or as a todo list app. You can also look at other Org ports under permissive licenses, e.g. org-ruby is an MIT-licensed Ruby gem that's used by GitHub to render .org files on their website. The orgize Rust crate is MIT-licensed as well.

Your Answer

By clicking “Post Your Answer”, you agree to our terms of service, privacy policy and cookie policy

Not the answer you're looking for? Browse other questions tagged or ask your own question.