Jorge: a minimal org-mode + Markdown site generator

A steady thread through this year's Markdown conversations is the push back toward plain text: keep your writing in simple files, and let tools turn it into whatever format you need at publish time. A new open-source project called Jorge carries that idea into the world of personal websites. Described by its author as a "personal (small + opinionated) site generator," it renders org-mode and Markdown files into a static site with a single command. It surfaced on Hacker News in August 2026 as a Show HN, and it is easy to see why it caught attention: it is a reminder that you do not need a cloud CMS, a JavaScript framework, or a build pipeline to publish a fast, portable blog.

If your mental model of "publishing" is still a hosted editor with a database, Jorge is a useful counterexample. You write .org or .md files in src/, and Jorge renders them into static HTML in target/. No server, no account, no lock-in — the kind of architecture we keep coming back to when we write about Markdown portability. The tool is ideal for the reader who wants a personal site they fully own, and it pairs naturally with converting Markdown to rich text for the platforms where you do not control the HTML.

What Jorge does — and how it works

Jorge is written in Go. The author, Facundo Olano, built it as a learning project inspired by Jekyll, leaning on two excellent parsers instead of writing his own: go-org renders org-mode files to HTML, and goldmark renders Markdown. The result is a binary you download for your platform and run. You do not need Node, Python, Ruby, or a container — just a single executable.

The workflow is deliberately short. You create a site with jorge init, which scaffolds a default layout, stylesheet, and a couple of sample posts. A local jorge serve gives you a live preview that auto-refreshes as you edit. To add a post you run jorge post "My First Post", which drops a ready-to-edit file with YAML front matter and a draft: true flag. Remove the flag, run jorge build, and the site renders to static files you can host anywhere. Sample posts created by jorge init include both a goodbye-markdown.md and a hello-org.org, nudging newcomers to try both formats.

# new site
$ jorge init myblog
# ...scaffolds layouts, styles, sample posts, feed.xml

# live preview with auto-refresh
$ cd myblog
$ jorge serve
serving at http://localhost:4001

# new post (draft by default)
$ jorge post "My First Post"
added src/blog/my-first-post.org

# publish it
$ sed -i '' '/^draft: true$/d' src/blog/my-first-post.org

# build static files
$ jorge build

Because posts stay as plain text until you build, the source is your permanent, portable record. That is the same philosophy behind a Markdown-to-rich-text workflow: the file is the truth, and any rendered output is just one view of it.

org-mode vs Markdown: which one should you write in?

Jorge's most distinctive feature is first-class org-mode support. org-mode is the legendary plain-text outliner built into Emacs, and for a certain kind of writer it is a complete second brain: notes, TODO lists, tables, and documents all live in one plain-text file with a powerful markup language. Markdown, by contrast, is the format the rest of the web standardized on — every editor, platform, and tool understands it. Jorge supporting both lets writers pick their favorite rather than being forced into one camp.

If you already live in org-mode, Jorge means your .org notes can become a website with no conversion step. If you are a Markdown-first writer, the .md path behaves exactly like any Markdown blog engine you have used — which is the safer default for most people, because Markdown remains the most portable format across tools. Our guide to the broader Markdown publishing landscape goes deeper into why that portability matters.

Where Jorge ends and md2rich begins

Here is the part that matters for anyone already reading this blog: Jorge and md2rich solve two different halves of the same "write once" idea, and they work well together. Jorge produces a website — HTML pages you host and control. But most of your writing does not live on a personal website. It goes to LinkedIn, X Articles, Medium, or Notion — closed platforms where you paste rich text rather than push HTML. For those destinations, the same Markdown file needs converting to formatted content you can paste directly.

That is exactly what md2rich does, and it reinforces the bigger point: your Markdown source is one asset with many outputs. With Jorge, one output is a static personal site. With md2rich, other outputs are rich-text posts on the platforms your readers actually use. This is the same write-once, publish-everywhere pattern from our deep dive on the topic, now with one more tool in the toolbox.

One Markdown source, two outputs: a worked example

Take a short snippet you might write for both your personal site and your social feed. The Markdown source:

# Why I write in Markdown

**Plain text is the most portable format there is.**

- One source file, no lock-in
- Renders to a website (Jorge), rich text (md2rich), or anything else
- Your words survive any tool that disappears

On your own site, Jorge renders that file into a clean, styled blog page — headings, bold, and bullets rendered as HTML you control. On LinkedIn, you paste the same content through md2rich and get native rich text: a bold headline, an emphasized first line, and a clean bulleted list, formatted the way the platform expects. Same Markdown, two very different destinations, zero rewriting.

A second example, this time with a link — the kind of thing you want working in both places:

# Publish once, everywhere

Write the source once.
Build your site with [Jorge](https://github.com/facundoolano/jorge).
Paste rich text with [md2rich](https://md2rich.com/).

On your website, that link is an href in your static HTML. On a platform, the same Markdown link becomes clickable rich text after a Markdown-to-rich-text conversion. The mental model is the same either way: write once in Markdown, and let the right tool turn it into the format each destination needs.

Is a minimal site generator right for you?

Jorge is not for everyone, and that is fine. It is minimal and opinionated by design — if you want themes, a plugin ecosystem, or a GUI, a heavier option is a better fit. But if your needs are simple — a personal blog, a portfolio, a project log — a single static binary that turns plain text into a fast site has real appeal. There is nothing to keep updated, nothing to secure, and no platform deciding how your content is presented. It is the closest thing to "just files" that a website can be.

The underlying lesson applies beyond Jorge specifically: the more of your writing stays in plain Markdown, the more options you keep. Whether the output is a static site, a rich-text post, a newsletter, or a Markdown copy for AI systems, you are never trapped by a tool. That is the bet underneath the whole write-once, publish-everywhere idea, and it is why tools like Jorge — and md2rich — are worth knowing about even if you never adopt them.

The bottom line

Jorge is a small, opinionated static site generator with real org-mode and Markdown support, and a nice example of the plain-text-first movement in 2026. It gives the "write once" crowd one more output: a fast, portable personal website you fully own. For the platform posts that go alongside it, md2rich covers the rich-text side from the exact same Markdown source. Together they are a clean, no-cloud, no-database publishing stack — one file, many destinations.

FAQ