Master Advanced Markdown: Pro Formatting Tricks & Real-World Examples

Markdown is the universal language of technical writing, documentation, and modern blogging. But beyond the basics, advanced markdown tricks unlock tables, footnotes, math, task lists, syntax highlighting, and more—empowering you to create rich, professional docs, GitHub READMEs, and knowledge bases. This guide covers every powerful feature with real-world examples, actionable tips, and best practices for writers, developers, and project owners.

A person writing on a laptop with markdown code visible on the screen, for documentation or blogging

How to Create Tables in Markdown (With Real Examples)

Markdown tables are ideal for displaying data, project changelogs, feature matrices, and even comparison charts. The syntax is simple but powerful—using pipes | to separate columns, and hyphens - for headers. Most Markdown processors (including GitHub, Jupyter, and static site generators) support tables.

Example Markdown Table Markdown: 
| Feature     | Supported | Notes             |
|------------|:---------:|-------------------|
| Bold Text  | Yes       | Use **bold** |
| Tables     | Yes       | GitHub compatible |
| Footnotes  | Limited   | Not all sites     |
Pro Use: Use markdown table generators for complex layouts. Try our Markdown Table Generator to speed up documentation and avoid syntax mistakes.
Rendered Output:
FeatureSupportedNotes
Bold TextYesUse **bold**
TablesYesGitHub compatible
FootnotesLimitedNot all sites
Tip: Use : in headers to align columns (e.g., :-- for left, --: for right).

How to Add Footnotes in Markdown

Footnotes are essential for academic, technical, or reference writing. Markdown allows you to add references and citations using the [^1] syntax for inline reference, and [^1]: Your footnote. for the actual note. Not all renderers support this, but GitHub and many static site generators do.

Example: 
This is an example sentence with a footnote.[^1]

[^1]: Here is the footnote text, with more details or citations.
Pro Use: Use footnotes for citing sources or adding context without cluttering your main text. Note: GitHub only partially supports footnotes in READMEs—test your output for compatibility.
Rendered Example:
This is an example sentence with a footnote.1

1. Here is the footnote text, with more details or citations.

How to Write Math Formulas in Markdown

Math and scientific writers rely on LaTeX or KaTeX for formulas. Many Markdown tools (like Jupyter or MkDocs) allow inline $...$ or block $$...$$ math with full LaTeX support. For GitHub, math support is limited—consider screenshots or SVGs for complex formulas.

Example: 
Inline: $E = mc^2$
Block:
$$
\frac{a^2 + b^2}{c^2}
$$
Pro Use: For technical documentation, check if your platform supports math rendering (Jupyter, MkDocs, HackMD do; GitHub does not in READMEs). For web, try KaTeX or MathJax integrations.
Rendered Example:
E = mc2
(a2 + b2) / c2
Tip: For static sites, consider rendering formulas as SVG for maximum compatibility.

Create Task Lists & Checkboxes in Markdown

Task lists turn your Markdown into interactive checklists, ideal for project planning, bug tracking, and meeting notes. Use - [ ] for an empty box, - [x] for checked. GitHub issues, PRs, and READMEs support this feature natively.

Example: 
- [x] Write documentation
- [ ] Add footnotes
- [x] Create tables
- [ ] Review PRs
Pro Use: Use Markdown checklists in GitHub issues or pull requests to track project milestones or QA steps. They render as clickable checkboxes.
Rendered Example:
  • Write documentation
  • Add footnotes
  • Create tables
  • Review PRs
Tip: Nested checklists and indents are also supported on GitHub and many tools.

Syntax Highlighting Code Blocks in Markdown

For blogs, documentation, and tutorials, syntax highlighting makes code readable. Use triple backticks () with an optional language hint (e.g., or ). Most modern Markdown engines support code highlighting.

Example: 

 def hello():
     print("Hello, Markdown!")
Pro Use: Use language hints for every code block to ensure proper highlighting in Jekyll, Hugo, MkDocs, or GitHub. For blogs, pick a code color theme that matches your branding.
Rendered Example: 
def hello():
    print("Hello, Markdown!")
Tip: Over 50+ languages are supported. Use text for plain text blocks.

Embedding HTML in Markdown (Custom Formatting)

Markdown lets you drop raw HTML for advanced formatting—tables, spans, divs, and styles. This is useful for custom layouts or features not supported natively. However, portability and security can be an issue, so use HTML sparingly and test across platforms.

Example: 
<div style="color:#17A2B8;font-weight:bold;">Custom HTML inside Markdown!</div>
Pro Use: Use HTML for badges, colored callouts, or advanced tables. Avoid unsafe tags (like <script>), and check your markdown processor's security policy.
Rendered Example:
Custom HTML inside Markdown!
Tip: Some static site generators sanitize or strip HTML—test before publishing.

Best Practices: Make Markdown Work for Docs, Blogs & GitHub

  • Write for Readability: Use headings (#), lists, and tables to break up text. Keep lines short for easy diffing in version control.
  • Cross-Platform Compatibility: Not all features work everywhere. Test your markdown in your target platform (GitHub, GitLab, Jupyter, static site generator, etc).
  • Keep It Clean: Use HTML only when absolutely necessary. Prefer native markdown for portability and accessibility.
  • Document Like a Pro: Use footnotes for references, task lists for project tracking, and code fences with language hints for code clarity.
  • Preview Before Publishing: Use a markdown preview tool to catch rendering issues before going live. Try our Markdown Preview Tool.

Advanced Markdown FAQ

Most modern markdown engines support tables, code highlighting, and task lists (e.g., GitHub, GitLab, Bitbucket, Jupyter, MkDocs, Hugo, Jekyll). Footnotes and math formulas are supported in Jupyter, MkDocs, and other documentation tools, but not in core GitHub READMEs. Always preview your markdown on your target site or tool to confirm which features are available.

GitHub READMEs fully support tables and task lists, but only recently started partial support for footnotes. If you're writing for GitHub, test footnotes in preview mode. For more complex docs, use GitHub Pages with Jekyll or MkDocs for full feature support.

Use triple backticks and specify the language, e.g., , , . Most markdown processors will highlight the code automatically. For static sites, you may need to enable a syntax highlighting plugin or theme (like Pygments, Prism.js, or Highlight.js).

Yes. Embedding HTML can break portability (your markdown may not render the same on all platforms) and may introduce security risks if unsafe tags or scripts are used. Many static site generators sanitize or strip HTML for safety. Use HTML sparingly, and never include <script> or potentially dangerous tags.

Use an online markdown preview tool that supports extended features (like our Markdown Preview Tool), or test in your actual documentation platform. For full compatibility, use tools like Typora, MarkText, or the built-in preview in VSCode. Always check math, tables, and footnotes on the actual site where you’ll publish.