Convert Wiki to ORG

Why Convert Wiki to ORG?

Converting Wiki markup to Org-mode format brings wiki content into one of the most powerful plain text productivity systems available. Org-mode, built into GNU Emacs, goes far beyond simple document formatting. It combines authoring, task management, scheduling, time tracking, and executable code blocks in a single integrated system. Converting wiki content to Org format enables all these capabilities.

The conversion maps wiki structural elements to their Org-mode equivalents. Wiki headings (== Heading ==) become Org headings (* Heading), bold text ('''bold''') becomes Org bold (*bold*), and wiki tables are converted to Org-mode pipe tables that support spreadsheet-style calculations. This systematic transformation preserves the content structure while unlocking Org-mode's features.

Org-mode excels at managing technical documentation as living documents. After conversion, you can add TODO states to section headings for tracking review status, schedule deadlines for content updates, embed executable code blocks for testing examples, and use tags for flexible cross-referencing. These capabilities make Org-mode ideal for maintaining documentation that requires active management.

For researchers and technical writers, converting wiki content to Org format enables reproducible research workflows. Code blocks can be executed inline, results are captured automatically, and the entire document can be exported to PDF, HTML, or LaTeX. This makes Org-mode a powerful authoring environment for content that originated as simple wiki pages.

Key Benefits of Converting Wiki to ORG:

• Task Integration: Add TODO states and deadlines to content sections
• Literate Programming: Embed and execute code blocks within documentation
• Agenda System: Schedule content reviews and updates with Org agenda
• Multi-Export: Export to PDF, HTML, LaTeX, Markdown, and more
• Table Calculations: Org tables support formulas and spreadsheet operations
• Hierarchical Outlining: Fold, rearrange, and restructure content efficiently
• Plain Text: Fully version-controllable with Git

Practical Examples

Example 1: Wiki Documentation to Org Outline

Input Wiki file (architecture.wiki):

== System Architecture ==

=== Frontend ===

The frontend uses '''React''' with ''TypeScript''.

* Component-based design
* Server-side rendering
* State management via Redux

=== Backend ===

The backend runs on '''Node.js'''.

# Install dependencies
# Configure environment
# Start the server

[[Deployment Guide|See deployment instructions]]

Output ORG file (architecture.org):

* System Architecture

** Frontend

The frontend uses *React* with /TypeScript/.

- Component-based design
- Server-side rendering
- State management via Redux

** Backend

The backend runs on *Node.js*.

1. Install dependencies
2. Configure environment
3. Start the server

[[deployment-guide.org][See deployment instructions]]

Example 2: Wiki Table to Org Table

Input Wiki file (schedule.wiki):

== Sprint Schedule ==

{| class="wikitable"
|-
! Sprint !! Start Date !! End Date !! Focus Area
|-
| Sprint 1 || Jan 6 || Jan 17 || Authentication
|-
| Sprint 2 || Jan 20 || Jan 31 || Dashboard
|-
| Sprint 3 || Feb 3 || Feb 14 || Reporting
|}

'''Note:''' Each sprint includes a '''demo''' on the last day.

Output ORG file (schedule.org):

* Sprint Schedule

| Sprint   | Start Date | End Date | Focus Area     |
|----------+------------+----------+----------------|
| Sprint 1 | Jan 6      | Jan 17   | Authentication |
| Sprint 2 | Jan 20     | Jan 31   | Dashboard      |
| Sprint 3 | Feb 3      | Feb 14   | Reporting      |

*Note:* Each sprint includes a *demo* on the last day.

Example 3: Wiki Guide to Org with Code Blocks

Input Wiki file (tutorial.wiki):

== Python Tutorial ==

=== Hello World ===

Create a file called hello.py:


print("Hello, World!")


=== Variables ===

Python uses ''dynamic typing'':


name = "Alice"
age = 30
print(f"{name} is {age}")

Output ORG file (tutorial.org):

* Python Tutorial

** Hello World

Create a file called =hello.py=:

#+BEGIN_SRC python
print("Hello, World!")
#+END_SRC

** Variables

Python uses /dynamic typing/:

#+BEGIN_SRC python
name = "Alice"
age = 30
print(f"{name} is {age}")
#+END_SRC

Frequently Asked Questions (FAQ)

Q: What is Org-mode?

A: Org-mode is a major mode for GNU Emacs that provides a plain text system for note-taking, task management, project planning, literate programming, and document authoring. Created by Carsten Dominik in 2003, it uses a hierarchical outline format with asterisk-based headings and supports features like TODO tracking, scheduling, code execution, and export to multiple formats.

Q: Do I need Emacs to use Org files?

A: While Emacs provides the full Org-mode experience, .org files are plain text and can be read in any text editor. Partial Org-mode support exists in VS Code (via extensions), Vim/Neovim (orgmode.nvim), and applications like Logseq and Organice. For basic reading and editing, any text editor works fine.

Q: How are wiki links converted to Org links?

A: Wiki internal links ([[Page|Text]]) are converted to Org link syntax ([[file][Text]]). External URLs are preserved in Org's bracket link format. The link targets may need adjustment depending on your file organization, but the link structure and display text are accurately converted.

Q: Can I add TODO tracking to the converted content?

A: Yes, after conversion, you can add Org-mode TODO states to any heading. Simply prefix a heading with a keyword like TODO, DONE, or IN-PROGRESS. Emacs Org-mode will then include these items in the agenda view, enabling task tracking for documentation sections that need review or updates.

Q: Are wiki code blocks converted to executable Org source blocks?

A: Yes, wiki code blocks (using source or pre tags with language specification) are converted to Org source blocks (#+BEGIN_SRC / #+END_SRC) with the language preserved. In Emacs, these blocks can be executed with C-c C-c, and results are captured inline, enabling literate programming workflows.

Q: Can I export the Org file to PDF?

A: Yes, Org-mode provides built-in export to PDF (via LaTeX), HTML, ODT, Markdown, and many other formats. In Emacs, use C-c C-e to access the export dispatcher. The structural information from the original wiki content (headings, lists, tables) produces well-formatted output in all export targets.

Q: How are wiki tables handled in Org format?

A: Wiki tables are converted to Org pipe-delimited tables, which have native support in Org-mode. Unlike wiki tables, Org tables support built-in spreadsheet formulas using Emacs Calc. You can add calculations to the converted tables, making them more powerful than the original wiki tables.

Q: Is Org format suitable for large documentation sets?

A: Absolutely. Org-mode handles large documents efficiently with its folding and outline navigation features. You can collapse entire sections to see the document structure at a glance, then expand sections as needed. For very large documentation, Org also supports splitting content across multiple files with cross-file linking.