I'm looking for a Markdown editor/converter that processes everything locally. Most online tools I've tried require uploading files to a server, which isn't ideal for confidential documents.

My ideal requirements are:

• No file uploads
• Browser-based or desktop
• Local processing
• PDF export
• Open source is a plus

Does anyone have recommendations or experience with tools that meet these requirements?

I recently built **Page to Markdown**, a free Chrome extension that converts web pages—or only the content you select—into clean, structured Markdown.

It was created to make everyday research, documentation, note-taking, and AI-assisted workflows faster and simpler.

Instead of manually copying content, removing navigation, fixing broken formatting, and rebuilding headings or lists, the extension lets you capture useful content in a few clicks.

# What is Page to Markdown?

**Page to Markdown** is a browser extension that converts web content into a ready-to-use `.md` file while preserving useful structure such as:

* Headings
* Lists
* Tables
* Links
* Code blocks
* Quotes
* Structured page content

You can then paste the result into:

* GitHub
* Obsidian
* Notion
* Documentation platforms
* Research notes
* Pull requests
* AI tools such as ChatGPT or Claude

# Three ways to capture content

**Main Content**

Removes navigation menus, advertisements, sidebars, and footers while keeping the main article or page content.

**Full Page**

Converts the complete visible page into Markdown. This is useful for websites that do not have a clearly defined article structure.

**Selection**

Highlight a paragraph, table, code example, or specific section and convert only that selected content.

# YAML front matter support

The extension can optionally add YAML front matter containing useful metadata such as:

---
title: "Page title"
source: "https:// example com"
captured: "2026-07-13"
---

This is particularly useful for Obsidian users, researchers, developers, content creators, and anyone building a structured personal knowledge base.

# Built for a better user experience

The goal was not only to create another Markdown converter, but to make the capture process feel quick and natural.

You can:

* Copy Markdown directly to your clipboard
* Download a dated `.md` file
* Right-click and choose **Copy Selection as Markdown**
* Open the extension using `Alt + Shift + M`
* Keep the original source URL and page metadata through YAML

# Free and privacy-first

The extension is completely free to use.

It was developed with privacy and responsible software design in mind:

* No servers
* No analytics
* No user accounts
* No background page monitoring
* No network requests
* No unnecessary host permissions

All conversion happens locally inside your browser.

The extension only accesses the page when you choose to run it, and the generated content goes only to your clipboard or Downloads folder.

# Open source and built for a good cause

The repository is public for anyone who wants to inspect the code, contribute, report issues, suggest improvements, or learn from the implementation.

I developed it as a small community-focused project: useful software should not always need a subscription, an account, or the collection of personal data.

Try it here:

https://chromewebstore.google.com/detail/fhijjebpfmoekacokgmpokikjacagpkh?utm_source=item-share-cb

I would genuinely appreciate feedback from developers, researchers, writers, students, Obsidian users, and anyone working with Markdown or AI tools.

# A little about the technical side

The extension is built using the Chrome Extensions platform and performs Markdown conversion entirely within the browser.

The core workflow includes:

* Content extraction from the active tab
* Main-content detection
* Selected-text capture
* HTML-to-Markdown conversion
* YAML metadata generation
* Clipboard integration
* Local `.md` file creation
* Minimal-permission browser access

GitHub link: [https://github.com/lakshithalk/page-to-markdown](https://github.com/lakshithalk/page-to-markdown))

The repository is public, and contributions, bug reports, feature requests, and technical feedback are welcome.

I work on a Markdown-like extension, and I'm adding a way to put a vector graphic directly in a document instead of referencing an external file. Before I lock the defaults I'd like a sanity check from people who write a lot of Markdown.

The syntax is a fence:

```img
<svg viewBox="0 0 24 24">
  <path fill="currentColor" d="M12 2l2.9 6.3 6.9.8-5.1 4.6z"/>
</svg>
```

The body gets sanitized first (script elements, event handlers, foreignObject, javascript: URLs and external references are all stripped), and then it is rendered one of two ways.

Default: sandboxed. The cleaned SVG is encoded into a data:image/svg+xml URI on an <img> tag. The browser sandboxes that: no script, no network requests, no access to the surrounding page. It holds even if my sanitizer turns out to have a bug, which is exactly why it's the default.

Source next to what it renders to: https://i.postimg.cc/kX4FnJS0/1-sandbox-default.png

Opt-in: inline. The cleaned SVG is emitted as a real <svg> element in the page, so currentColor and normal CSS (including dark mode) apply to it. That's what people actually want for icons. The cost is that the sanitizer becomes the only thing standing between the document and the DOM. It gets switched on by the application embedding the renderer, never by the document itself, so a document can't promote its own content out of the sandbox.

I think the main advantages and why I wanted this in the first place:

• The graphic travels with the document. No asset folder, no broken relative paths, one file you can paste anywhere and share easily.
• It diffs. A changed icon shows up as readable lines in git instead of "binary file changed".
• Nothing is fetched at render time, so it works offline and can't phone home.
• The alternative people reach for today is raw HTML passthrough, which would require way more sanitizing and whitelisting (also of elements). This is strictly safer than that.

What I'm unsure about:

1. Is putting image source inside a text document reasonable at all, or does it wreck the plain-text readability that makes Markdown worth using in the first place?
2. If you'd use it: is sandboxed-only good enough, or is theming (the icon following your page's text color) the entire point, making a sandbox-only version pointless?
3. What do you do today? Commit SVG files next to the document, paste base64 data URIs, drop into raw HTML, or just avoid inline vector graphics?

Would this be something you could see yourself using?
Or for easier communication with AI even, maybe, once it learned this extension? Since all is inside one stream/file.

I know there are also risks of enlarging the document too much, depending on the images.
Just wondering if I missed a good argument for or against it before I actually merge my POC.