Convert ORG to RST

Drag and drop files here or click to select.
Max file size 100mb.
Uploading progress:

ORG vs RST Format Comparison

Aspect ORG (Source Format) RST (Target Format)
Format Overview
ORG
Emacs Org-mode

Plain text markup format created for Emacs in 2003. Designed for note-taking, task management, project planning, and literate programming. Features hierarchical structure with collapsible sections, TODO states, scheduling, and code execution.

Emacs Native Literate Programming
RST
reStructuredText

Lightweight markup language created by David Goodger in 2001 for the Python Docutils project. The standard format for Python documentation, used extensively with Sphinx for generating project documentation, API references, and Read the Docs.

Python Standard Sphinx Compatible
Technical Specifications
Structure: Hierarchical outline with * headers
Encoding: UTF-8
Format: Plain text with markup
Processor: Emacs Org-mode, Pandoc
Extensions: .org
Structure: Section headers with underlines
Encoding: UTF-8
Format: Plain text with semantic markup
Processor: Sphinx, Docutils, Pandoc
Extensions: .rst, .rest
Syntax Examples

Org-mode syntax:

#+TITLE: My Document
#+AUTHOR: Jane Doe

* Introduction

This is *bold* and /italic/.

** Subsection

#+BEGIN_SRC python
def hello():
    print("Hello")
#+END_SRC

- Item one
- Item two

reStructuredText syntax:

===========
My Document
===========

:Author: Jane Doe

Introduction
============

This is **bold** and *italic*.

Subsection
----------

.. code-block:: python

    def hello():
        print("Hello")

- Item one
- Item two
Content Support
  • Hierarchical headers with * levels
  • TODO states and task management
  • Scheduling and deadlines
  • Tags and properties
  • Tables with spreadsheet formulas
  • Literate programming (Babel)
  • Code blocks with execution
  • Links and cross-references
  • LaTeX math support
  • Section headers with underlines
  • Inline markup (bold, italic, code)
  • Directives (code-block, image, note)
  • Roles for semantic markup
  • Cross-references and citations
  • Tables (grid and simple)
  • Autodoc for Python APIs
  • Math formulas (LaTeX)
  • Footnotes and substitutions
Advantages
  • Powerful task management
  • Literate programming support
  • Code execution (40+ languages)
  • Spreadsheet-like tables
  • Agenda and scheduling
  • Deep Emacs integration
  • Extensive customization
  • Python documentation standard
  • Sphinx integration (powerful)
  • Read the Docs hosting
  • Autodoc for API generation
  • Extensible directive system
  • Multi-format output
  • Semantic roles
  • Cross-project references
Disadvantages
  • Requires Emacs for full features
  • Steep learning curve
  • Limited outside Emacs ecosystem
  • Complex syntax for advanced features
  • Less portable than other formats
  • Strict whitespace requirements
  • Header syntax can be confusing
  • Steeper learning curve than Markdown
  • Less intuitive for beginners
  • Primarily Python-focused
Common Uses
  • Personal knowledge management
  • Task and project management
  • Literate programming
  • Research notes
  • Journaling and logging
  • Agenda and scheduling
  • Python project documentation
  • API reference generation
  • Read the Docs projects
  • Technical manuals
  • Sphinx documentation sites
  • PEP (Python Enhancement Proposals)
Best For
  • Emacs users
  • Task management
  • Literate programming
  • Personal notes
  • Python documentation
  • Sphinx projects
  • API documentation
  • Technical writing
Version History
Introduced: 2003 (Carsten Dominik)
Current Version: 9.6+ (2024)
Status: Active development
Primary Tool: GNU Emacs
Introduced: 2001 (David Goodger)
Specification: Docutils/PEP 287
Status: Stable, actively maintained
Primary Tool: Sphinx, Docutils
Software Support
Emacs: Native support (Org-mode)
Vim/Neovim: org.nvim, vim-orgmode
VS Code: Org Mode extension
Other: Logseq, Obsidian (plugins)
Sphinx: Primary documentation generator
Read the Docs: Native hosting platform
GitHub: RST rendering support
IDEs: PyCharm, VS Code (plugins)

Why Convert ORG to RST?

Converting Org-mode documents to reStructuredText is essential when you need to integrate your documentation with Python projects or Sphinx-based documentation systems. RST is the de facto standard for Python documentation, used by virtually all major Python projects.

If you've been writing technical notes or documentation in Org-mode and want to publish them on Read the Docs or include them in a Sphinx documentation project, converting to RST provides seamless integration with the Python documentation ecosystem.

RST offers powerful features for technical documentation that complement Org-mode's strengths. Sphinx's autodoc feature can automatically generate API documentation from Python docstrings, and RST's directive system allows for rich, semantic content that goes beyond basic markup.

The conversion is particularly valuable for Python developers who use Org-mode for personal notes but need to contribute to or maintain project documentation in RST format. This bridges the gap between personal productivity tools and project standards.

Key Benefits of Converting ORG to RST:

  • Python Ecosystem: Standard format for Python project documentation
  • Sphinx Integration: Full compatibility with Sphinx documentation generator
  • Read the Docs: Direct publishing to Read the Docs platform
  • API Documentation: Combine with autodoc for automatic API docs
  • Cross-References: Powerful linking between documentation pages
  • Multi-Format Output: Generate HTML, PDF, EPUB from single source
  • Professional Standard: Industry-accepted documentation format

Practical Examples

Example 1: Basic Document Structure

Input ORG file (guide.org):

#+TITLE: Getting Started Guide
#+AUTHOR: Documentation Team

* Introduction

Welcome to the *project documentation*.
This guide helps you get started quickly.

** Prerequisites

Before you begin, ensure you have:

- Python 3.8 or higher
- pip package manager
- Virtual environment (recommended)

Output RST file (guide.rst):

====================
Getting Started Guide
====================

:Author: Documentation Team

Introduction
============

Welcome to the **project documentation**.
This guide helps you get started quickly.

Prerequisites
-------------

Before you begin, ensure you have:

- Python 3.8 or higher
- pip package manager
- Virtual environment (recommended)

Example 2: Code Blocks and Directives

Input ORG file (api.org):

* API Reference

Install the package:

#+BEGIN_SRC bash
pip install mypackage
#+END_SRC

#+BEGIN_NOTE
This requires Python 3.8 or higher.
#+END_NOTE

** Usage Example

#+BEGIN_SRC python
from mypackage import Client

client = Client(api_key="your-key")
result = client.process(data)
#+END_SRC

Output RST file (api.rst):

API Reference
=============

Install the package:

.. code-block:: bash

    pip install mypackage

.. note::

    This requires Python 3.8 or higher.

Usage Example
-------------

.. code-block:: python

    from mypackage import Client

    client = Client(api_key="your-key")
    result = client.process(data)

Example 3: Tables and Links

Input ORG file (reference.org):

* Configuration Options

| Option   | Type    | Default | Description         |
|----------+---------+---------+---------------------|
| debug    | boolean | false   | Enable debug mode   |
| timeout  | integer | 30      | Request timeout (s) |
| retries  | integer | 3       | Number of retries   |

See [[https://docs.example.com][official documentation]] for more details.

For installation, see [[*Prerequisites][the prerequisites section]].

Output RST file (reference.rst):

Configuration Options
=====================

+----------+---------+---------+---------------------+
| Option   | Type    | Default | Description         |
+==========+=========+=========+=====================+
| debug    | boolean | false   | Enable debug mode   |
+----------+---------+---------+---------------------+
| timeout  | integer | 30      | Request timeout (s) |
+----------+---------+---------+---------------------+
| retries  | integer | 3       | Number of retries   |
+----------+---------+---------+---------------------+

See `official documentation <https://docs.example.com>`_ for more details.

For installation, see :ref:`the prerequisites section`.

Frequently Asked Questions (FAQ)

Q: What is reStructuredText (RST)?

A: reStructuredText is a lightweight markup language created for Python documentation. It's the foundation of Sphinx, the documentation generator used by Python, Django, Flask, and countless other projects. RST files can be converted to HTML, PDF, and other formats.

Q: How are Org-mode headers converted to RST?

A: Org-mode headers (* for level 1, ** for level 2, etc.) are converted to RST section headers with underlines. Level 1 uses "=" underlines (and overlines for document title), level 2 uses "-", level 3 uses "~", and so on.

Q: What happens to Org-mode code blocks?

A: Code blocks (#+BEGIN_SRC ... #+END_SRC) are converted to RST's code-block directive. The language specification is preserved, so Python, JavaScript, and other language blocks maintain syntax highlighting in Sphinx.

Q: Can I use the output with Sphinx?

A: Yes! The generated .rst files are fully compatible with Sphinx. Add them to your docs/ directory and include them in your toctree. Sphinx will process them along with your other documentation files.

Q: How are links converted?

A: External links [[url][text]] become RST inline links `text <url>`_. Internal links to sections require manual adjustment to use RST's :ref: role for cross-referencing within Sphinx projects.

Q: What about Org-mode tables?

A: Org tables are converted to RST grid tables with proper formatting. RST tables require specific alignment of + and | characters, which the converter handles automatically.

Q: Are admonitions (NOTE, WARNING) supported?

A: Yes, Org-mode special blocks like #+BEGIN_NOTE are converted to RST directives like .. note::. RST supports note, warning, tip, important, and other admonition types.

Q: Can I publish to Read the Docs?

A: Absolutely! Read the Docs natively supports RST files through Sphinx. After converting your Org files to RST, set up a Sphinx project and connect it to Read the Docs for automatic building and hosting.