Erste Schritte
Überschriften & Absätze
Verwende # für Überschriften (1-6 Ebenen). Die alternative Syntax nutzt === für H1 und --- für H2. Zwischen Absätzen muss eine Leerzeile stehen. Markdown ist so gestaltet, dass es als reiner Text gut lesbar bleibt.
# Heading 1
## Heading 2
### Heading 3
#### Heading 4
##### Heading 5
###### Heading 6
Alternative Heading 1
=====================
Alternative Heading 2
---------------------
This is a paragraph. Just write
plain text. Leave a blank line
between paragraphs.Zeilenumbrüche
Zwei Leerzeichen oder ein Backslash am Zeilenende erzeugen einen harten Zeilenumbruch (<br>). Ohne diese ist ein einzelner Zeilenumbruch ein weicher Umbruch, der zu einem Absatz zusammengefügt wird. Lasse zwischen Absätzen immer eine Leerzeile.
First line
Second line (two trailing spaces above)
Or use a backslash at end of line\
to force a line break.
Soft wrap without break:
just continue on the next line
and it joins into one.Kommentare
Markdown hat keine offizielle Kommentarsyntax, aber HTML-Kommentare (<!-- -->) funktionieren in den meisten Renderern und werden in der Ausgabe ausgeblendet. Der [//]: #-Trick nutzt eine leere Link-Referenz für Notizen. Kommentare bleiben im Quelltext sichtbar.
<!-- HTML comments work in most Markdown -->
[//]: # (This is a comment)
[//]: # "Another comment style"
<!--
Multi-line comment
not rendered in output
-->Leerzeichen & Einrückung
Vier führende Leerzeichen machen aus Text einen Codeblock — Achte auf versehentliche Einrückung. Die Einrückung ist für verschachtelte Listen wichtig (2-4 Leerzeichen pro Ebene). Tabs werden meist als 4 Leerzeichen behandelt. Verwende durchgängig Leerzeichen, um Rendering-Probleme zwischen Parsern zu vermeiden.
Paragraph one.
This is an indented code block
because of 4 spaces.
> Quoted text needs > prefix.
Three spaces is just text
(less than 4).Horizontale Linien
Drei oder mehr Bindestriche, Sternchen oder Unterstriche erzeugen eine horizontale Linie (<hr>). Bindestriche sind am gebräuchlichsten. Leerzeichen zwischen den Zeichen sind erlaubt. Setze zur besseren Übersicht Leerzeilen um horizontale Linien. Verwechsele --- (Linie) nicht mit # (Überschrift).
---
***
___
* * *
Text above
---
Text belowTextformatierung
Fett
Doppelte Sternchen oder Unterstriche erzeugen fetten Text (<strong>). Sternchen werden bevorzugt, da Unterstriche innerhalb von Wörtern nicht funktionieren (snake_case). Innerhalb von fettem Text kannst du andere Hervorhebungen verschachteln. HTML-<strong>-Tags funktionieren als Rückfalloption.
**bold text**
__also bold__
**bold with *italic* inside**
<strong>HTML bold also works</strong>
**bold**Kursiv
Einfache Sternchen oder Unterstriche erzeugen kursiven Text (<em>). Sternchen funktionieren auch innerhalb von Wörtern; Unterstriche behandeln Wort-interne Unterstriche als Literal (also no_italic_here). Nutze <em> als Rückfalloption. Kursiv dient der Betonung, nicht nur der Gestaltung.
*italic text*
_also italic_
*italic*
<em>HTML italic</em>
normal *italic* normalFett + Kursiv kombiniert
Dreifache Sternchen/Unterstriche erzeugen fette und kursive Formatierung. Du kannst sie auch verschachteln: Fett mit Kursiv darin oder umgekehrt. Die Reihenfolge ist für das Rendering egal, sollte aber der Lesbarkeit halber konsistent sein.
***bold and italic***
___also both___
**_bold and italic_**
*__bold and italic__*
combine **bold** and *italic*Durchgestrichen
Doppelte Tilden (~~) erzeugen durchgestrichenen Text — Teil von GitHub Flavored Markdown und inzwischen weit verbreitet. Die HTML-Tags <del> und <s> sind gleichwertige Rückfalloptionen. Im ursprünglichen Markdown-Standard ist Durchgestrichen nicht enthalten.
~~strikethrough~~
~~crossed out text~~
<del>HTML delete</del>
<s>HTML strikethrough</s>
~~done~~ and ~~pending~~Markieren / Hervorheben
Doppelte Gleichheitszeichen (==) zum Hervorheben sind eine Erweiterung, die einige Parser unterstützen (nicht im GFM-Kern). Der HTML-Tag <mark> funktioniert überall. Nutze Hervorhebungen sparsam, um auf Schlüsselbegriffe hinzuweisen — Übergebrauch mindert die Wirkung.
==highlighted text==
<mark>HTML mark</mark>
This is ==important== text.
Compare **bold**, *italic*, ==mark==.Tief- & Hochgestellt
Tilden- (tiefgestellt) und Zirkumflex-Syntax (hochgestellt) (~ ~ und ^ ^) sind Erweiterungen, die weder im Standard-Markdown noch in GFM enthalten sind — unterstützt von Pandoc, R Markdown und einigen anderen. Für universelle Unterstützung verwende HTML <sub> und <sup> oder Unicode-Zeichen.
H~2~O is water
E = mc^2^
x^2^ + y^2^ = r^2^
1st^st^ January
CO~2~ emissionsListen
Ungeordnete Listen
Verwende -, * oder + für Einträge ungeordneter Listen — wähle eines und bleibe dabei konsistent (- ist am häufigsten). Rücke verschachtelte Einträge mit 2-4 Leerzeichen ein. Verschiedene Markierungen in derselben Liste können bei manchen Parsern Probleme verursachen. Ein Eintrag pro Zeile.
- item one
- item two
- item three
* asterisk works too
+ plus sign also works
- sub-item (indent 2 spaces)
- another sub-itemGeordnete Listen
Geordnete Listen verwenden Zahlen mit Punkt. Die tatsächlichen Zahlen müssen nicht fortlaufend sein — Markdown nummeriert sie neu. Um bei einer bestimmten Zahl zu beginnen, verwende sie als erste (10. beginnt bei 10). Mit 1. bei allen Einträgen wird automatisch nummeriert.
1. first
2. second
3. third
1. auto-numbered
1. still increments
1. third item
10. starts at 10
11. nextVerschachtelte Listen
Rücke Einträge verschachtelter Listen um 2-4 Leerzeichen ein (4 ist am sichersten bei gemischten Typen). Geordnete und ungeordnete Listen können auf verschiedenen Ebenen gemischt werden. Tiefe Verschachtelung (3+ Ebenen) leidet Lesbarkeit — denke über eine Umstrukturierung nach. Halte die Einrückung konsistent.
1. top level
- nested unordered
- second nested
2. back to top
1. nested ordered
2. another
3. third top
- fruits
- apple
- granny smith
- bananaAufgabenlisten
Die Syntax für Aufgabenlisten (- [x] und - [ ]) ist eine GitHub-Flavored-Markdown-Erweiterung. Die Checkbox wird auf GitHub/GitLab interaktiv gerendert. Funktioniert mit geordneten und ungeordneten Listen. Ideal für READMEs, Issue-Tracker und Fortschrittsverfolgung.
- [x] completed task
- [ ] incomplete task
- [ ] another todo
1. [x] done
2. [ ] not done
- [x] Write the docs
- [ ] Review PR
- [ ] DeployLockere vs. kompakte Listen
Sind Listeneinträge durch Leerzeilen getrennt, ist die Liste 'loose' (jeder Eintrag in <p> gewickelt). Ohne Leerzeilen ist sie 'tight' (ohne <p>-Wrapper). Das beeinflusst den Abstand in der HTML-Ausgabe. Füge Leerzeilen gezielt ein, um den Absatzumbruch zu steuern.
- tight item
- tight item
- tight item
- loose item
- loose item
- loose itemListen mit mehreren Absätzen
Um mehrere Absätze oder Blockelemente in einem Listeneintrag zu haben, rücke die Fortsetzung um 4 Leerzeichen ein (oder richte sie am Inhalt der Listenmarkierung aus). Leerzeilen trennen die Teilblöcke. Das ist für komplexe Listenstrukturen essenziell, aber leicht falsch zu machen.
- First item
Second paragraph of first item.
- Second item
> A blockquote inside a list item.
>
> Must be indented to align.
- Third itemLinks
Inline-Links
Inline-Links verwenden [text](url). Ein optionaler Titel in Anführungszeichen erscheint als Tooltip beim Hover. Relative Links funktionieren für die interne Seitennavigation. Anker-Links (#id) springen zu Elementen mit passender id. Die URL darf keine Leerzeichen enthalten — verwende %20 für Leerzeichen.
[link text](https://example.com)
[link with title](https://example.com "Title here")
[relative link](/about)
[anchor](#section-id)Referenz-Links
Referenz-Links halten den Text lesbar, indem sie die URL auslagern. Definiere Referenzen an beliebiger Stelle im Dokument ([ref]: url). Referenzdefinitionen werden nicht gerendert. Die implizite Form [text][] nutzt den Text selbst als Referenz-ID. Referenzen können wiederverwendet werden.
[link text][ref]
[ref]: https://example.com "Optional title"
[link text][1]
[1]: https://example.com
[link text]
[link text]: https://example.comAuto-Links & URLs
Bloße URLs werden in GitHub Flavored Markdown automatisch verlinkt. Für Standardkonformität setze URLs in spitze Klammern (<url>). Die Winkelklammer-Form funktioniert in allen Markdown-Varianten. Auto-Verlinkung lässt sich in manchen Parsern deaktivieren.
https://example.com
<https://example.com>
<http://www.google.com>
Auto-linking bare URLs is supported
in GFM: visit https://example.com now.E-Mail-Auto-Links
E-Mail-Adressen in spitzen Klammern werden zu klickbaren mailto:-Links. Die ursprüngliche Markdown-Spezifikation unterstützte die Form <text@domain>. Manche Renderer verschleiern E-Mail-Adressen, um Spam-Ernte zu erschweren. Nutze auf öffentlichen Websites besser ein Kontaktformular für besseren Spam-Schutz.
<[email protected]>
Contact: <[email protected]>
<John Doe <[email protected]>>
Mailto links work in most renderers.Link-Titel
Link-Titel erscheinen als Tooltip beim Hover. Verwende doppelte oder einfache Anführungszeichen um den Titel. Titel sind optional und rein ein UX-/SEO-Hinweis. Sie ersetzen nicht den Linktext — Screenreader ignorieren sie womöglich. Halte Titel kurz.
[hover for title](https://example.com "Example Site")
[reference with title][a]
[a]: https://example.com "Example Site"
[title with single quotes](https://example.com 'Single')Interne & Anker-Links
Anker für Überschriften werden in den meisten Parsern automatisch aus dem Überschriftentext erzeugt (kleingeschrieben, Leerzeichen zu Bindestrichen, Satzzeichen entfernt). Für eigene IDs verwende HTML <a id="..."> oder die {#id}-Attributerweiterung (Pandoc/marked). Anker-Links sind essenziell für Inhaltsverzeichnisse.
## Section Heading
[jump to Section](#section-heading)
[back to top](#top)
<a id="custom-id"></a>
[custom anchor](#custom-id)
## Heading {#explicit-id}Bilder
Grundlegendes Bild
Die Bildsyntax ist wie die für Links, aber mit vorangestelltem !. Der Alt-Text ist für Barrierefreiheit erforderlich — er beschreibt das Bild für Screenreader und erscheint, wenn das Bild nicht lädt. Der Pfad kann relativ, absolut oder eine URL sein. Der Titel ist optional.


Bild mit Alt-Text
Alt-Texte sollten aussagekräftig und prägnant sein — beschreibe den Zweck des Bildes, nicht nur 'Bild'. Für dekorative Bilder ist ein leerer Alt-Text (alt='') akzeptabel, damit Screenreader sie überspringen. Verwende nie 'image of' oder 'picture of' — Screenreader kündigen das ohnehin an.


Verlinkte Bilder
Um ein Bild zu verlinken, verschachtere die Bildsyntax in der Linksyntax: [](url). Häufig für Thumbnails, die zu Vollbild-Versionen führen, Badges mit CI-Status und Logos zur Startseite. Der Alt-Text sollte das Ziel beschreiben, nicht nur das Bild.
[](https://example.com/full)
[](/)
[](https://ci.example.com)Referenz-Bilder
Referenz-Bilder verwenden denselben Referenzstil wie Links, mit vorangestelltem !. Definiere die Bildreferenz einmal und verwende sie wieder. Nützlich, wenn dasselbe Bild mehrfach erscheint oder um bildlastige Absätze lesbar zu halten.
![alt text][img-ref]
[img-ref]: https://example.com/image.png "Title"
![alt][logo]
[logo]: /assets/logo.pngBildgröße & Figure
Standard-Markdown hat keine Syntax für Bildgrößen — verwende HTML <img> mit width/height-Attributen. Prozentuale Breiten ermöglichen responsive Größen. <figure> + <figcaption> liefert semantische Bildunterschriften (HTML5). Einige erweiterte Markdown-Varianten (Pandoc) unterstützen {width=300}.
<img src="image.png" width="300" height="200" alt="sized image">
<img src="banner.png" width="100%" alt="responsive">
<figure>
<img src="diagram.png" alt="flowchart">
<figcaption>Figure 1: System flow</figcaption>
</figure>Inline-Code & Escaping
Inline-Code
Setze Inline-Code in einfache Backticks. Um Backticks innerhalb von Code anzuzeigen, verwende doppelte Backticks als Begrenzer (oder mehr). Inline-Code wird monospaced gerendert und nicht als Markdown geparst. Ideal für Dateinamen, Befehle und Code-Bezeichner.
Use the `printf()` function.
Inline code: `const x = 42;`
Code with backticks: ``use `code` here``
A `<div>` element.Backticks in Code-Spans escapen
Um einen Backtick innerhalb eines Code-Spans einzufügen, verwende mehr Backticks als Begrenzer, als innen vorkommen: doppelte Backticks um einen einzelnen Backtick. Außerhalb von Code-Spans escape einen Backtick mit einem Backslash. Der schließende Fence muss zur Länge des öffnenden passen.
To show a backtick inside code,
use more backticks as delimiters:
`` ` `` one backtick
`` a`b `` backtick inside text
Use \ to escape outside code:
A literal backtick: \`Code-Spans & Leerzeichen
Code-Spans erhalten interne Leerzeichen exakt. Ein gängiger Trick: Inhalt mit einem führenden bzw. abschließenden Leerzeichen umschließen, um Leerzeichen am Rand anzuzeigen, die sonst beschnitten würden. Jeweils ein Leerzeichen auf jeder Seite wird automatisch entfernt.
` spaced ` (spaces preserved)
` code ` with one space pad
`function f() { return; }`
` multi word code `Backslash-Escapes
Der Backslash escape besondere Markdown-Zeichen: Backtick, Sternchen, Unterstrich, geschweifte Klammern, eckige Klammern, runde Klammern, Raute, Plus, Minus, Punkt, Ausrufezeichen und den Backslash selbst. Escaping rendert das Zeichen als Literal. Escape nur Zeichen, die sonst als Formatierung interpretiert würden.
\*not italic\*
\_not italic\_
\#not a heading
\[not a link](url)
\`not code\`
\\backslash itself
\!not an imageZu escapende Zeichen
Dies sind die escapbaren Zeichen in Markdown. Nicht alle müssen überall escapet werden — # ist nur am Zeilenanfang relevant, - im Listenkontext usw. Im Zweifel: escapen. Geschweifte und runde Klammern müssen meist nur in bestimmten Kontexten escapet werden (Links, Template-Strings).
\\ backslash
\` backtick
\* asterisk
\_ underscore
\{ \} curly braces
\[ \] square brackets
\( \) parentheses
\# hash
\+ plus
\- minus
\. dot
\! exclamationCodeblöcke
Eingerückte Codeblöcke
Eine Einrückung um 4 Leerzeichen (oder einen Tab) erzeugt einen Codeblock. Eingerückte Codeblöcke haben kein Syntax-Highlighting und keinen Sprach-Tag. Sie können nicht in Listeneinträgen verwendet werden (gelten als Fortsetzung). Bevorzuge für neue Inhalte Fenced Code Blocks — eingerückte Blöcke sind Legacy.
Normal paragraph.
// indented code (4 spaces)
function hello() {
console.log("hi");
}
Back to normal text.Fenced Code Blocks
Dreifache Backticks oder Tilden erzeugen Fenced Code Blocks. Fences sind eingerückten Blöcken vorzuziehen — sie sind eindeutig und unterstützen Sprachangaben. Tilden (~~~) sind nützlich, wenn der Code selbst dreifache Backticks enthält. Schließe den Fence immer mit derselben Zeichenanzahl.
```
plain code block
multiple lines
```
~~~
also a fenced block
using tildes
~~~Syntax-Highlighting
Füge direkt nach dem öffnenden Fence einen Sprachbezeichner für Syntax-Highlighting hinzu (z. B. js, python). Die meisten Renderer nutzen highlight.js oder Prism. Übliche Aliasse: js, ts, py, rb, sh, json, html, css. Bei unbekannter Sprache lasse ihn für reinen Monospace weg.
```javascript
const greet = (name) => {
console.log(`Hello, ${name}!`);
};
```
```python
def greet(name):
print(f"Hello, {name}!")
```
```bash
echo "Hello, $USER"
```Verschachtelte Code-Fences
Um Backticks in einem Codeblock anzuzeigen, verwende einen anderen Fence (Tilden für Backtick-Inhalt oder mehr Backticks, als innen vorkommen). Vier Backticks umschließen Inhalte mit dreifachen Backticks. Der schließende Fence muss zur Länge des öffnenden passen.
Use four backticks to wrap triple backticks:
````
```js
console.log("inside");
```
````
Or use tildes to wrap backtick content:
~~~
```js
code with backticks
```
~~~Code in Listen
Fenced Code Blocks in Listeneinträgen müssen eingerückt werden, um mit dem Listentext zu fluchten (meist 3 Leerzeichen bei - Listen, 4 bei 1. Listen). Eingerückte Codeblöcke in Listen brauchen 8 Leerzeichen (4 für die Liste + 4 für den Code). Die richtige Ausrichtung ist eine der kniffligeren Markdown-Aufgaben.
1. Item with code:
```
code block indented to align
```
2. Next item with inline `code`.
- Or indent code 4 spaces beyond
the list marker (8 total).Blockzitate
Einfaches Blockzitat
Das Zeichen > beginnt ein Blockzitat. Du kannst jede Zeile oder nur die erste voranstellen — die meisten Parser verbinden aufeinanderfolgende Zeilen. Blockzitate werden als eingerückte, gestylte Zitate gerendert (<blockquote>). Nutze sie für Zitate, Hinweise und hervorgehobene Auszüge.
> This is a blockquote.
> It can span multiple lines.
> Or just prefix the first line
and continuation lines without >
will still be part of the quote.Mehrzeiliges Blockzitat
Verwende leere >-Zeilen, um Absätze innerhalb eines Blockzitats zu trennen (sonst verschmelzen sie). Das > in einer Leerzeile hält das Zitat offen. Ohne Leerzeilen zwischen Absätzen fließt der Text als ein Absatz weiter. Beende das Zitat immer mit einer normalen Zeile.
> First paragraph of quote.
>
> Second paragraph of quote.
>
> > Nested quote starts here.
> > Continues on next line.
End of quote.Verschachtelte Blockzitate
Mehrere >-Zeichen erzeugen verschachtelte Blockzitate (>> für zwei Ebenen, >>> für drei). Füge Leerzeichen zur besseren Lesbarkeit hinzu. Tiefe Verschachtelung (3+ Ebenen) wird schwer lesbar und stylbar — lieber abflachen. Jede Ebene erhöht die Einrückung in der HTML-Ausgabe.
> Outer quote
>
> > Inner nested quote
> > still nested
>
> Back to outer
> Outer
>> Deeper
>>> Deepest levelBlockzitate mit anderen Elementen
Blockzitate können die meisten Markdown-Elemente enthalten: Überschriften, Listen, Code, Hervorhebungen, sogar Tabellen. Stelle jeder Zeile > (und ein Leerzeichen) voran, damit sie im Zitat bleiben. Das macht Blockzitate für Hinweise mächtig, doch komplexe Inhalte erfordern sorgfältige >-Ausrichtung.
> ## Heading in quote
>
> - list item one
> - list item two
>
> *italic* and **bold** work too.
>
> ```
> code block inside quote
> ```Blockzitat mit Quellenangabe
Markdown hat keine formale Zitat-Syntax. Übliche Konventionen: den Autor in einer neuen Zeile mit Gedankenstrich voranstellen oder HTML <blockquote> mit <footer> und <cite> für semantische Zitate verwenden. Für akademische Zitate ziehe eine Fußnote mit der Quelle in Betracht.
> Be the change you wish to see
> in the world.
> — Mahatma Gandhi
> "Simplicity is the soul of efficiency."
> — Austin Freeman
<blockquote>
<p>Quote text.</p>
<footer>— <cite>Author</cite></footer>
</blockquote>Tabellen
Einfache Tabelle
Tabellen nutzen Pipes (|) für Spaltentrennung und Bindestriche für die Kopfzeile. Die Kopfzeile ist erforderlich. Pipes an den Zeilenenden sind optional, verbessern aber die Lesbarkeit. Spaltenbreiten sind egal — Zellen passen sich an. Tabellen sind eine GitHub-Flavored-Markdown-Erweiterung.
| Name | Age | City |
|-------|-----|----------|
| Alice | 30 | NYC |
| Bob | 25 | London |
| Carol | 35 | Paris |Zellenausrichtung
Doppelpunkte in der Trennzeile steuern die Ausrichtung: :--- links, :---: zentriert, ---: rechts. Ohne Doppelpunkte ist die Voreinstellung links. Die Ausrichtung gilt für die gesamte Spalte und setzt text-align im HTML-Output. Nützlich für Zahlenspalten (rechtsbündig) und Kopfzeilen (zentriert).
| Left | Center | Right |
|:-------|:------:|-------:|
| left | center | right |
| L | C | R |
| Default | alignment |
|---------|-----------|
| no mark | left |Tabelle mit Formatierung
Zellen können Inline-Markdown enthalten: fett, kursiv, Code, Links, Durchgestrichen, Emoji. Blockelemente (Überschriften, Listen, Codeblöcke) funktionieren nicht in Zellen — nötigenfalls HTML verwenden. Halte Zellinhalte kurz für die Lesbarkeit. Escape Pipes mit Backslash, um literale Pipes anzuzeigen.
| Feature | Status | Notes |
|------------|:------:|--------------------|
| **Bold** | done | *finished* |
| `code` | wip | [docs](docs.md) |
| ~~old~~ | removed| gone in v2 |
| [link][1] | done | see [ref][1] |Komplexe Tabelle
Tabellen skalieren auf viele Zeilen und Spalten, bleiben aber pro Zelle einfach. Für Code-Spans mit Kommas in Backticks einschließen. Literale Pipes mit Backslash und Pipe escapen. Komplexe Daten (mehrzeilige Zellen, verschachtelte Tabellen) erfordern HTML <table>. Ziehe eine Liste in Betracht, wenn die Tabelle zu breit wird.
| Name | Role | Skills | Available |
|-------|---------|---------------------|:---------:|
| Alice | Lead | `js`, `ts`, `go` | yes |
| Bob | Junior | `py`, `sql` | no |
| Carol | Senior | `rust`, `c++` | yes |
Escaped pipe: \| literalTabellen-Tipps & Grenzen
Markdown-Tabellen sind begrenzt: kein Zellenverbinden, kein mehrzeiliger Inhalt, keine Blockelemente, keine verschachtelten Tabellen. Dafür rohes HTML verwenden. Halte Tabellen klein und übersichtlich. Braucht eine Tabelle Fußnoten oder langen Text, teile sie auf. Tools wie TablesGenerator.com helfen beim schnellen Erstellen.
| A | B |
|---|---|
| 1 | 2 |
Tip: Use \| to escape pipes.
Limitation: no multi-line cells,
no blockquotes, no lists in cells.
For complex tables, use HTML:
<table><tr><td>cell</td></tr></table>Fußnoten
Einfache Fußnoten
Fußnoten verwenden [^id]-Marker im Text und [^id]: Definition an anderer Stelle. Die id kann eine Zahl oder ein Wort sein. Renderer erzeugen klickbare hochgestellte Nummern und einen Fußnotenbereich unten. Unterstützt von GFM, Pandoc und den meisten modernen Parsern.
Here is a sentence with a footnote.[^1]
[^1]: This is the footnote text.
Another sentence.[^note]
[^note]: Footnotes can use named labels.Mehrere Referenzen
Eine Fußnote kann mehrfach referenziert werden — jedes [^id] verweist auf dieselbe Definition. Fortsetzungszeilen der Fußnotendefinition werden eingerückt. Die erste Referenz bekommt üblicherweise die hochgestellte Nummer; weitere verlinken auf dieselbe Notiz.
Use the term[^term] twice[^term] in the text.
[^term]: A single definition referenced
multiple times.
First[^1] and second[^1] reference.
[^1]: One definition, two links back.Inline-Fußnoten
Inline-Fußnoten (^[text]) betten den Inhalt direkt an der Referenz ein, unterstützt von Pandoc und einigen Erweiterungen (nicht im GFM-Kern). Sie halten alles an einem Ort, können aber den Lesefluss stören. Nutze sie für kurze Notizen; lange sind besser als Referenzen.
Here is an inline footnote^[The note text
right here in the body.] in a sentence.
Pandoc also supports: ^[inline notes].
And another[^1].
[^1]: Traditional reference style.Positionierung von Fußnoten
Fußnotendefinitionen können überall im Dokument stehen — Renderer sammeln und zeigen sie am Ende. Rücke Fortsetzungszeilen ein (4 Leerzeichen). Fußnoten funktionieren in Blockzitaten und Listeneinträgen. Die Position im Quelltext beeinflusst die Ausgabeposition nicht.
Body text with a note.[^1]
More paragraphs here.
[^1]: Definitions can appear anywhere.
They float to the bottom in output.
> Even inside blockquotes.[^2]
[^2]: The renderer collects all notes
and renders them at the end.Fußnoten mit Code & Formatierung
Fußnotendefinitionen unterstützen Inline-Markdown (fett, kursiv, Code) und mehrabsätzigen Inhalt (Fortsetzungszeilen um 4 Leerzeichen einrücken). Eingerückte Codeblöcke darin brauchen 8 Leerzeichen. Halte Fußnoten prägnant — lange technische Inhalte gehören eher in den Haupttext oder einen Anhang.
See the API[^api] for details.
[^api]: Use `fetch('/api/data')` to call.
Supports **bold** and *italic*.
Multi-paragraph: indent each line.
Code blocks need indentation:
indented code inside footnoteDefinitionslisten
Einfache Definitionsliste
Definitionslisten verwenden einen Begriff in einer Zeile, dann einen Doppelpunkt (:) mit der Definition. Unterstützt von PHP Markdown Extra, Pandoc und einigen Erweiterungen (nicht im GFM-Kern). Wird als <dl><dt><dd> gerendert. Nützlich für Glossare und Begriffs-Definition-Paare.
Term
: Definition of the term.
Markdown
: A lightweight markup language.
HTML
: HyperText Markup Language.Mehrere Begriffe
Mehrere aufeinanderfolgende Begriffe (ohne Doppelpunkt) können sich eine Definition teilen. Jeder Begriff wird ein <dt>, die Definition ein <dd>. Nützlich, wenn ein Konzept mehrere Namen oder Aliasse hat. Begriffe in einzelnen Zeilen halten.
CSS
Cascading Style Sheets
: A style sheet language.
JS
JavaScript
: A programming language.
Both terms
: Share one definition.Mehrere Beschreibungen
Mehrere aufeinanderfolgende Definitionen (jede mit Doppelpunkt beginnend) für einen Begriff erzeugen mehrere <dd>-Elemente. Nützlich, um mehrere getrennte Bedeutungen oder Aspekte eines Begriffs aufzulisten. Jede Doppelpunkt-Zeile ist ein eigener Definitionseintrag.
Markdown
: A markup language.
: A tool for writing for the web.
Apple
: A fruit.
: A technology company.Verschachtelte Definitionslisten
Verschachtelte Definitionslisten erfordern das Einrücken der inneren Liste (2-4 Leerzeichen) innerhalb der äußeren Definition. Die Parser-Unterstützung variiert — nicht alle Renderer beherrschen Verschachtelung. Für komplexe hierarchische Begriffsstrukturen ist HTML <dl> zuverlässiger. Teste in deinem Ziel-Renderer.
Term
: Definition one.
Nested term
: Nested definition.
: Definition two for top term.Definitionslisten mit Blockelementen
Definitionslisten-Einträge können mehrere Absätze, Blockzitate und Codeblöcke enthalten — rücke die Fortsetzung um 4 Leerzeichen ein (über den Doppelpunkt hinaus). Codeblöcke darin brauchen insgesamt 8 Leerzeichen. Das ist mächtig, aber fragil; komplexe Inhalte sind in HTML <dl> sicherer.
Markdown
: A markup language.
With multiple paragraphs in the
definition (indent 4 spaces).
> Blockquote inside definition.
: Second definition with code:
indented code (8 spaces)Inhaltsverzeichnis
Automatisches Inhaltsverzeichnis
Die meisten Parser erzeugen standardmäßig kein automatisches Inhaltsverzeichnis. Einige (marked mit dem toc-Plugin, MDX) unterstützen [TOC]- oder {:toc}-Platzhalter. Tools wie Doctoc und markdown-toc generieren es aus Überschriften. Statische Websites lesen Anker der Überschriften per Komponente zur Build- oder Laufzeit.
## Table of Contents
1. [Introduction](#introduction)
2. [Installation](#installation)
3. [Usage](#usage)
4. [FAQ](#faq)
Some parsers auto-generate a TOC
with `[TOC]` or `{:toc}` markers.Manuelles Inhaltsverzeichnis
Ein manuelles Inhaltsverzeichnis ist eine verschachtelte Liste von Links zu Überschriften-Ankern. Anker-IDs ergeben sich aus dem Überschriftentext (Kleinbuchstaben, Bindestriche für Leerzeichen, Satzzeichen entfernt). Rücke entsprechend der Überschriftenhierarchie ein. Bei Änderungen manuell aktualisieren oder einen Generator nutzen.
# My Document
## Contents
- [Intro](#intro)
- [Setup](#setup)
- [Prerequisites](#prerequisites)
- [Install](#install)
- [Usage](#usage)
## Intro
...Regeln zur Anker-Erzeugung
Die Anker-Erzeugung variiert je nach Parser. Übliche Regeln: Kleinbuchstaben, Leerzeichen zu Bindestrichen, Satzzeichen entfernen, Alphanumerik behalten. GitHub behält Emoji und etwas Unicode. Zahlen und Punkte werden oft entfernt. Im Zweifel: das gerenderte HTML prüfen, um die tatsächliche id zu finden.
## Hello World -> #hello-world
## Hello, World! -> #hello-world
## C++ & Rust -> #c--rust
## Uber Heading -> #uber-heading
## 1. Getting Started -> #1-getting-started
## API v2.0 -> #api-v20Eigene Anker-IDs
Für zuverlässige Anker füge explizite IDs hinzu. Die {#id}-Attributsyntax funktioniert in Pandoc, marked und einigen Erweiterungen. Der HTML-Trick <a id="..."> funktioniert überall — vor oder in der Überschrift platzieren. Eigene IDs überstehen Änderungen des Überschriftentexts.
## Heading {#custom-id}
<a id="my-anchor"></a>
## Heading
## Heading<a id="also"></a>
[link to custom](#custom-id)Inhaltsverzeichnis-Navigation & Zurück-Links
Zurück-nach-oben-Links verbessern die Navigation in langen Dokumenten. <details>/<summary> in HTML erzeugt ein einklappbares Inhaltsverzeichnis — ideal für Sidebars oder lange READMEs. Kombiniere mit Anker-Links für flüssige Navigation. Füge scroll-margin-top im CSS hinzu, um fixe Header auszugleichen.
## Section
Content here.
[Back to top](#table-of-contents)
---
<details>
<summary>Table of Contents</summary>
- [Section 1](#section-1)
- [Section 2](#section-2)
</details>Emoji & Sonderzeichen
Emoji-Shortcodes
Emoji-Shortcodes (:name:) werden von GitHub/GitLab unterstützt (mit dem EmojiOne/Twemoji-Set). Es gibt Tausende benannte Emoji. Shortcodes sind praktisch, aber nicht portabel — in Nicht-GFM-Parsern erscheinen sie womöglich als Text. Für maximale Kompatibilität rohe Unicode-Emoji verwenden.
:smile: :heart: :thumbsup: :rocket:
GFM supports shortcodes:
:sparkles: new feature :tada:
:checkered_flag: launch!
:bug: fixed issue #42Häufige Emoji
Die meisten modernen Editoren und Renderer verarbeiten rohe Unicode-Emoji direkt — einfach einfügen. Shortcodes sind GitHub-spezifisch. Emoji können Ton und Status vermitteln (Haken/Kreuz für Ergebnisse, Käfer für Bugs). In formalen Dokumenten sparsam einsetzen; in READMEs und Changelogs sind sie ideal.
:smile: smile :heart: heart :thumbsup: thumbsup
:rocket: rocket :star: star :warning: warning
:check: check :x: cross :bulb: bulb
:fire: fire :tada: tada :bug: bug
:book: book :wrench: wrench :zap: zapHTML-Entities
HTML-Entities funktionieren in Markdown, da es an HTML durchgereicht wird. Verwende & für literale kaufmännische Unds (besonders in URLs/Attributen), < > für spitze Klammern, © ® ™ für Symbole. Numerische Formen (©) und Hex (©) decken jedes Unicode-Zeichen ab.
& < > " '
© ® ™
— – …
© ©
Use & to show a literal &.Sonderzeichen
Markdown wandelt einfache Interpunktion standardmäßig nicht in typografische Zeichen (smart quotes) um — HTML-Entities verwenden oder Unicode einfügen. Gedankenstriche und typografische Anführungszeichen verbessern die Typografie. Viele Editoren korrigieren das automatisch. Für Pfeile und Symbole sind Entities am klarsten.
-- em dash (or —)
-- en dash (or –)
... ellipsis (or …)
' ' curly quotes (‘ ’)
" " curly quotes (“ ”)
-> arrow (or →)
(tm) (r) (c)Emoji & Markdown kombinieren
Emoji lassen sich mit allen Markdown-Elementen kombinieren: Überschriften, Listen, fett, Links, Blockzitate. Sie geben Changelogs, READMEs und Issue-Templates visuelle Hinweise. Emoji-Nutzung konsistent halten (z. B. eine Changelog-Konvention beibehalten). Emoji in formalem/akademischem Schreiben vermeiden.
## New Features
- :sparkles: Added dark mode
- :bug: Fixed login bug
- :memo: Updated docs
**Status:** :white_check_mark: Ready
> :warning: **Warning:** Deprecated!
[:book: Read the docs](/docs)Mermaid-Diagramme
Mermaid-Flowchart
Mermaid ist eine textbasierte Diagrammsprache, die von GitHub, GitLab und vielen statischen Site-Generatoren gerendert wird. Mermaid-Code in einen mermaid-Fenced-Block einschließen. flowchart TD (von oben nach unten) oder LR (von links nach rechts) legt die Richtung fest. Knoten nutzen [], {} und () für verschiedene Formen.
```mermaid
flowchart TD
A[Start] --> B{Is it?}
B -->|Yes| C[Do it]
B -->|No| D[Do not]
C --> E[End]
D --> E
```Mermaid-Sequenzdiagramm
Sequenzdiagramme zeigen Interaktionen zwischen Teilnehmern über die Zeit. ->> ist ein durchgezogener Pfeil (Anfrage), -->> ein gestrichelter (Antwort). participant deklariert Akteure. Nützlich, um API-Abläufe, Protokolle und Nachrichtenaustausch zu dokumentieren. Auf GitHub automatisch gerendert.
```mermaid
sequenceDiagram
participant A as Alice
participant B as Bob
A->>B: Hello Bob!
B-->>A: Hi Alice!
A->>B: How are you?
B-->>A: Good, thanks!
```Mermaid-Klassendiagramm
Klassendiagramme modellieren objektorientierte Strukturen. + bedeutet public, - private, # protected. <|-- steht für Vererbung. Mermaid unterstützt Assoziationen, Kompositionen und Interfaces. Ideal, um Code-Architektur direkt in Markdown zu dokumentieren.
```mermaid
classDiagram
class Animal {
+String name
+int age
+makeSound() void
}
class Dog {
+fetch() void
}
Animal <|-- Dog
```Mermaid-Zustandsdiagramm
Zustandsdiagramme zeigen Zustandsübergänge. [*] markiert Start-/Endzustände. Pfeile beschriften Übergänge mit Ereignissen (state --> state: event). Nützlich zur Dokumentation von Protokollen, UI-Zuständen und Objekt-Lebenszyklen. stateDiagram-v2 ist die moderne Syntax.
```mermaid
stateDiagram-v2
[*] --> Idle
Idle --> Processing: start
Processing --> Done: complete
Processing --> Error: fail
Done --> [*]
Error --> [*]
```Mermaid-Gantt-Diagramm
Gantt-Diagramme visualisieren Projektzeitpläne. dateFormat legt das Datums-Parsing fest. Aufgaben verwenden id, Start, Dauer (z. B. 7d). 'after a1' verkettet Aufgaben. Abschnitte gruppieren verwandte Aufgaben. Nützlich für READMEs und Projektpläne — auf GitHub ohne externe Tools automatisch gerendert.
```mermaid
gantt
title Project Schedule
dateFormat YYYY-MM-DD
section Design
Spec :a1, 2024-01-01, 7d
Mockups :after a1, 5d
section Build
Develop :2024-01-13, 14d
Test :7d
```Mermaid-Tortendiagramm
Tortendiagramme zeigen Anteile in Prozent (Werte sind relativ). Der Titel ist optional. Labels in Anführungszeichen, Werte nach Doppelpunkten. Mermaid unterstützt auch Git-Graphen, ER-Diagramme, Journey-Maps und Mindmaps — alles in Markdown auf unterstützten Plattformen renderbar.
```mermaid
pie title Browser Market Share
"Chrome" : 65
"Safari" : 18
"Edge" : 5
"Firefox" : 3
"Other" : 9
```GitHub Flavored Markdown
Aufgabenlisten (GFM)
GFM-Aufgabenlisten (GitHub Flavored Markdown) rendern auf GitHub interaktive Checkboxen. [x] ist angehakt, [ ] nicht angehakt. Sie funktionieren in Issues, PRs, Kommentaren und READMEs. Fortschrittsbalken erscheinen in Issue-Listen. Die Syntax ist inzwischen weit über GitHub hinaus unterstützt.
- [x] Done task
- [ ] Todo task
- [ ] Another todo
## Project Status
- [x] Design
- [x] Implement
- [ ] Test
- [ ] DeployDurchgestrichen (GFM)
GFM ergänzt das Standard-Markdown um Durchgestrichen (~~text~~). Es funktioniert über Zeilen hinweg und lässt sich mit anderer Formatierung kombinieren. Wird als <del> gerendert. Ursprünglich eine GFM-Erweiterung, inzwischen in den CommonMark-Spez-Ergänzungen. Nützlich für Änderungen und Deprecated-Hinweise.
~~deleted text~~
old ~~price~~ new
~~this line is wrong~~
Combine: **bold ~~struck~~ text**
~~multi-line
strikethrough~~Tabellen (GFM)
Tabellen sind ein GFM-Feature (nicht im ursprünglichen Markdown). Die Pipe-Syntax mit Kopfzeile und Trennzeile ist erforderlich. GFM-Tabellen unterstützen Ausrichtung, Inline-Formatierung und escapte Pipes. Für komplexe Tabellen (Verbinden, Verschachtelung) auf HTML ausweichen.
| Feature | Status |
|------------|:------:|
| Tables | yes |
| Tasks | yes |
| Auto-links | yes |
Tables are core to GFM, not in
the original Markdown spec.GitHub Alerts
GitHub Alerts (ab 2023) verwenden einen [!TYPE]-Marker in der ersten Zeile eines Blockzitats: NOTE, TIP, IMPORTANT, WARNING, CAUTION. Sie werden auf GitHub mit eigenen Farben und Icons gerendert. Ideal für Hinweise in READMEs und Dokumentation. Die Syntax ist GitHub-spezifisch.
> [!NOTE]
> Useful information that users
> should know.
> [!WARNING]
> Urgent info about risks.
> [!IMPORTANT]
> Key information.
> [!TIP]
> Helpful advice.Gesperrtes rohes HTML
GFM filtert rohes HTML aus Sicherheitsgründen — <script>, <style>, <title>, teils <iframe> und Event-Handler werden entfernt. Das verhindert XSS in nutzergenerierten Inhalten. Sicheres HTML wie <details>, <kbd>, <sup> wird durchgelassen. Kenne die Allow-List deines Renderers, wenn du HTML mischst.
GFM sanitizes some HTML tags:
<script>alert('xss')</script>
<style>body { color: red; }</style>
<title>Page</title>
These are stripped for security.Auto-Links (GFM)
GFM verlinkt bloße URLs (https://...) und www.-Domains automatisch, ohne spitze Klammern. Für Portabilität funktionieren spitze Klammern (<url>) in allen Varianten. Auto-Verlinkung kann überraschen — verwende spitze Klammern, wenn du eine URL wörtlich neben anderem Text anzeigen willst.
Visit https://example.com now.
www.google.com auto-links too.
<https://example.com> always works.
In GFM, bare URLs and www. links
become clickable automatically.Erweiterte Syntax
Hervorheben
Die ==text==-Hervorhebungssyntax ist eine Erweiterung (weder in GFM noch CommonMark) — unterstützt von manchen Parsern wie markdown-it mit Plugin. Der HTML-Tag <mark> wird universell unterstützt. Hervorhebungen betonen Schlüsselbegriffe; Übergebrauch mindert die Wirkung.
==highlighted text==
<mark>HTML highlight</mark>
Some parsers (not GFM core) support
==this syntax== for highlighting.
Use <mark> for universal support.Tief- & Hochgestellt
Tiefgestellt (~text~) und hochgestellt (^text^) sind Pandoc-/markdown-it-Erweiterungen, kein Standard. Für universelles Rendering HTML <sub>/<sup> oder Unicode verwenden. Nützlich in wissenschaftlichen und mathematischen Inhalten in Markdown.
H~2~O (subscript)
x^2^ (superscript)
E = mc^2^
H~2~SO~4~
Pandoc/R Markdown support ~ and ^.Attribut-Syntax
Die {#id .class key=val}-Attributsyntax (Pandoc, einige markdown-it-Plugins) hängt HTML-Attribute an Elemente. Nützlich für Styling-Hooks, eigene Anker und Link-Ziele. Nicht portabel — fällt in nicht unterstützten Parsern zu wörtlichem Text zurück. Sparsam einsetzen.
## Heading {#id .class}
{width=50%}
[link](url){target=_blank}
> Quote {.callout}Eigene Container
Eigene Container (:::type ... :::) werden von VuePress, Docusaurus, VitePress und ähnlichen Docs-Tools unterstützt. Sie rendern als gestylte Hinweisboxen. Der Typ entspricht einer CSS-Klasse. Ideal für thematisierte Docs, aber nicht portabel auf reine Markdown-Renderer.
:::note
This is a note container.
:::
:::warning
This is a warning.
:::
::: details Open me
Hidden content.
:::Mathematik & LaTeX (KaTeX)
Mathe-Unterstützung hängt vom Renderer ab: GitHub unterstützt $...$ inline und $$...$$ als Block (mit MathJax/KaTeX). Nicht alle Markdown-Parser unterstützen Mathe. Für maximale Kompatibilität Mathe in Bilder rendern oder MathJax direkt nutzen. Nützlich für wissenschaftliche und technische Dokumentation.
Inline: $E = mc^2$ in a sentence.
Block:
$$
\int_0^\infty e^{-x^2} dx = \frac{\sqrt{\pi}}{2}
$$
Some parsers support \( \) and
\[ \] delimiters too.Tools & Editoren
VS Code
VS Code hat eine integrierte Markdown-Vorschau und ein reiches Extension-Ökosystem. Markdown All in One ergänzt Shortcuts (fett, Inhaltsverzeichnis, Vorschau). markdownlint erzwingt Stil. Preview Enhanced unterstützt Diagramme, Mathe und Exporte. Konfiguriere den Zeilenumbruch für komfortables Bearbeiten.
# VS Code Markdown extensions:
- Markdown All in One
- Markdown Preview Enhanced
- markdownlint
- Pandoc
# Built-in preview: Ctrl+Shift+V
# Side-by-side: Ctrl+K V
# Settings:
"[markdown]": {
"editor.wordWrap": "on",
"editor.quickSuggestions": true
}Typora
Typora ist ein beliebter WYSIWYG-Markdown-Editor — er rendert beim Tippen inline und macht den Split-Pane-Workflow überflüssig. Er unterstützt GFM, Tabellen, Code-Fences, Mathe und Mermaid. Exportiert über eingebaute Tools in viele Formate. Kostenpflichtig, aber ausgereift; ideal für schreiborientierte Workflows.
Typora: a WYSIWYG Markdown editor.
- Live rendering as you type
- No split pane (instant preview)
- Supports tables, diagrams, math
- Export to PDF, HTML, Word, LaTeX
- Themes and custom CSS
Shortcuts:
- Ctrl+/ toggle source code mode
- Ctrl+B bold, Ctrl+I italicObsidian
Obsidian speichert Notizen als lokale Markdown-Dateien mit mächtigen Features: Wiki-Links, Backlinks, eine Graph-Ansicht und Tags. Es erweitert Markdown um Callouts, Embeds und Dataview. Ideal für Zettelkasten und persönliches Wissensmanagement. Für persönliche Nutzung kostenlos.
Obsidian: a Markdown knowledge base.
- Plain-text .md files (local-first)
- Bidirectional [[wiki links]]
- #tags and nested tags
- Backlinks and graph view
- Plugins for almost everything
- Callouts: > [!note] Title
[[note|alias]] for renamed links.Markdown-Lint
markdownlint erzwingt konsistenten Stil über Markdown-Dateien hinweg. Regeln in .markdownlint.json konfigurieren. Übliche Deaktivierungen: MD013 (Zeilenlänge) für Fließtext, MD033 (Inline-HTML), wenn HTML nötig ist. MD040 erinnert daran, Code-Fences mit einer Sprache zu taggen. Lässt sich in CI und Editoren integrieren.
# .markdownlint.json (config)
{
"MD013": false,
"MD024": { "siblings_only": true },
"MD033": false,
"default": true
}
# Rules (examples):
# MD013 line length
# MD024 no duplicate headings
# MD033 no inline HTML
# MD040 fenced code needs languagePandoc
Pandoc ist das 'Schweizer Taschenmesser' der Dokumentkonvertierung — Markdown zu/von HTML, PDF, Word, LaTeX, EPUB, Slides. Es unterstützt Markdown-Erweiterungen (Zitate, Mathe, Definitionslisten, Raw-Attribute). Das Flag -s erzeugt eigenständige Dokumente. Unverzichtbar für akademische und Publishing-Workflows.
# Convert Markdown to many formats:
pandoc input.md -o output.html
pandoc input.md -o output.pdf
pandoc input.md -o output.docx
pandoc input.md -o slides.pdf
# Markdown to a self-contained HTML:
pandoc input.md -s -o output.html
# With a table of contents:
pandoc input.md --toc -o output.html
# Support extensions:
pandoc -f markdown+smart input.mdOnline-Editoren
Online-Editoren sind praktisch für schnelle Änderungen und zum Teilen. StackEdit und Dillinger sind vollwertige Einzel-Editoren. HackMD/HedgeDoc ergänzen Echtzeit-Kollaboration. Der GitHub-Web-Editor hat einen Preview-Tab. Alle unterstützen Standard-Markdown; GFM-Features funktionieren am besten im GitHub-Editor.
Popular online Markdown editors:
- StackEdit (stackedit.io)
Full-featured, syncs to cloud.
- Dillinger (dillinger.io)
Clean, exports to many formats.
- HackMD / HedgeDoc
Real-time collaborative editing.
- GitHub web editor
Preview tab for .md files.
- Markdown Live Preview
Lightweight, instant preview.Best Practices
Lesbarkeit zuerst
Markdowns Kernprinzip ist Lesbarkeit als reiner Text. Bevorzuge die lesbarste Syntax: # Überschriften, - Listen, **fett**. Vermeide zu tiefe Verschachtelung und übermäßige Formatierung. Wenn der Quelltext im Texteditor angenehm zu lesen ist, nutzt du Markdown gut.
# Good: readable as plain text
## Section
Use **bold** for emphasis, not
__bold__ (asterisks are clearer).
# Bad: hard to read raw
##Section or ***overkill***
Tip: Preview raw Markdown often.
If it reads well as text, it is good.Zeilenlänge & Umbruch
Zwei gültige Ansätze: Hard-Wrap (ein Satz pro Zeile) liefert saubere git-Diffs und einfaches Bearbeiten; Soft-Wrap (ein Absatz pro Zeile) erspart Umbruch-Arbeit. Wähle pro Projekt einen und bleibe konsistent. Passe die Umbruchbreite des Editors entsprechend an (meist 80-120 Zeichen).
# Hard wrap (one sentence per line):
This is sentence one.
This is sentence two.
# Soft wrap (paragraph as one line):
This is a long paragraph that
continues on without hard breaks,
relying on editor wrapping.
# Many projects prefer one sentence
# per line for clean git diffs.Konsistenz
Markdown bietet mehrere Syntaxen für dasselbe Ergebnis (fett ** vs. __, Listen - vs. * vs. +). Wähle pro Projekt eine Konvention und setze sie mit markdownlint durch. Konsistenz senkt die kognitive Last für Leser und Mitwirkende und erleichtert automatisierte Verarbeitung.
# Pick one style and stick to it:
- Use - for lists (not * or +)
- Use ** for bold (not __)
- Use * for italic (not _)
- Use ``` for fences (not ~~~)
- Use # for headings (not ===/--)
Consistent style is more
maintainable and professional.Best Practices für Links
Verwende Referenz-Links für lange URLs, um den Fließtext lesbar zu halten. Inline-Links für kurze, lokale Referenzen. Beschreibender Linktext verbessert Barrierefreiheit und SEO — vermeide 'hier klicken'. Titel liefern Kontext als Tooltip. Gruppiere Referenzdefinitionen am Ende der Sektion oder des Dokuments.
# Reference links for long URLs:
See the [docs][docs] for details.
[docs]: https://example.com/very/long/url
# Inline for short links:
Edit [index.js](index.js).
# Title for context:
[API](api.md "REST API reference")
Keep link text descriptive,
not 'click here' or 'link'.Barrierefreiheit
Barrierefreiheit zählt auch in Markdown: aussagekräftige Alt-Texte für Bilder (leerer Alt-Text für dekorative), beschreibender Linktext (nicht 'hier klicken'), korrekte Überschriftenhierarchie (keine Ebenen überspringen) und semantisches HTML (kbd, abbr, cite), wo Markdown nicht ausreicht. Screenreader sind darauf angewiesen.
# Always add alt text to images:

# Empty alt for decorative images:

# Descriptive link text:
[Read the installation guide](install.md)
# Avoid: [click here](url)
# Use heading hierarchy in order.
# Use semantic HTML when needed:
<kbd>Ctrl</kbd> + <kbd>C</kbd>Häufige Fehler
Häufige Stolperfallen: fehlende Leerzeilen um Blockelemente (Listen, Zitate, Code), inkonsistente Einrückung in verschachtelten Listen, ungeschlossene Code-Fences und gemischte Tabs/Leerzeichen. Vor dem Veröffentlichen immer die Vorschau prüfen. markdownlint ausführen, um Probleme automatisch zu finden. Im Ziel-Renderer testen.
# Missing blank line before lists:
Text
- item # may merge with text!
# Fix:
Text
- item
# Unclosed code fence:
```
code
# (missing closing fence)
# Inconsistent list indentation:
- a
- b (2 spaces)
- c (3 spaces — may break)Verwandte Markdown-Snippets
Copy-paste ready code for common tasks.
Headings
Six levels of ATX and Setext headings.
Links and Images
Inline, reference, and auto links plus images.
Code Blocks
Fenced, indented, and inline code.
Tables
GFM tables with column alignment.
Lists
Ordered, unordered, and nested lists.
Blockquotes
Single, multi-line, and nested quotes.
Emphasis
Italic, bold, strikethrough, and escaping.
Task Lists
GFM checkboxes for to-do items.
Was this helpful?