diff --git a/.github/workflows/publish.yml b/.github/workflows/publish.yml
index 7eb7355..9ad7f68 100644
--- a/.github/workflows/publish.yml
+++ b/.github/workflows/publish.yml
@@ -5,23 +5,39 @@ on:
     types: [created]
 
 jobs:
-  deploy:
+  build:
     runs-on: ubuntu-latest
     steps:
-    - uses: actions/checkout@v2
-    - name: Set up Python 3.8
-      uses: actions/setup-python@v2
+    - uses: actions/checkout@v4
+    - name: Set up Python 3.9
+      uses: actions/setup-python@v5
       with:
-        python-version: 3.8
+        python-version: 3.9
     - name: Install build dependencies
       run: |
-        python -m pip install --upgrade pip wheel
+        python -m pip install --upgrade pip wheel build
     - name: Build package
       run: |
-        python setup.py sdist bdist_wheel
-    - name: Publish a Python distribution to PyPI
-      uses: pypa/gh-action-pypi-publish@v1.4.1
+        python -m build
+    - name: Upload Artifact
+      uses: actions/upload-artifact@v4
       with:
-        user: __token__
-        password: ${{ secrets.PYPI_UPLOAD_API_TOKEN }}
-
+        name: docstring-to-markdown dist ${{ github.run_number }}
+        path: ./dist
+  pypi-publish:
+    name: Upload release to PyPI
+    runs-on: ubuntu-latest
+    needs: [build]
+    environment:
+      name: pypi
+      url: https://pypi.org/p/docstring-to-markdown
+    permissions:
+      id-token: write
+    steps:
+    - name: Download artifacts
+      uses: actions/download-artifact@v4
+      with:
+        name: docstring-to-markdown dist ${{ github.run_number }}
+        path: ./dist
+    - name: Publish package distributions to PyPI
+      uses: pypa/gh-action-pypi-publish@release/v1
diff --git a/.github/workflows/tests.yml b/.github/workflows/tests.yml
index 6ccb4e8..8bd7e07 100644
--- a/.github/workflows/tests.yml
+++ b/.github/workflows/tests.yml
@@ -11,20 +11,17 @@ jobs:
     strategy:
       matrix:
         os: [ubuntu-latest]
-        python-version: [3.7, 3.8, 3.9, '3.10', '3.11']
-        include:
-          - os: ubuntu-20.04
-            python-version: 3.6
+        python-version: [3.8, 3.9, '3.10', '3.11', '3.12', '3.13']
     runs-on: ${{ matrix.os }}
     steps:
-    - uses: actions/checkout@v2
+    - uses: actions/checkout@v4
     - name: Set up Python ${{ matrix.python-version }}
-      uses: actions/setup-python@v2
+      uses: actions/setup-python@v5
       with:
         python-version: ${{ matrix.python-version }}
     - name: Install test dependencies
       run: |
-        python -m pip install --upgrade pip wheel
+        python -m pip install --upgrade pip wheel build
         python -m pip install -r requirements-dev.txt
     - name: Temporary installation
       run: python -m pip install -e .
@@ -36,8 +33,8 @@ jobs:
         mypy docstring_to_markdown
     - name: Build package
       run: |
-        python setup.py sdist bdist_wheel
+        python -m build
     - name: Install package
-      run: python -m pip install --find-links=dist --no-index --ignore-installed docstring_to_markdown
+      run: python -m pip install --find-links=dist --ignore-installed docstring_to_markdown
     - name: Pip check
       run: python -m pip check
diff --git a/README.md b/README.md
index 2f09ef6..97a3703 100644
--- a/README.md
+++ b/README.md
@@ -6,9 +6,9 @@
 
 On the fly conversion of Python docstrings to markdown
 
-- Python 3.6+
-- currently can recognise reStructuredText and convert multiple of its features to Markdown
-- in the future will be able to convert Google docstrings too
+- Python 3.7+ (tested on 3.8 up to 3.13)
+- can recognise reStructuredText and convert multiple of its features to Markdown
+- since v0.13 includes initial support for Google-formatted docstrings
 
 ### Installation
 
@@ -16,7 +16,6 @@ On the fly conversion of Python docstrings to markdown
 pip install docstring-to-markdown
 ```
 
-
 ### Example
 
 Convert reStructuredText:
@@ -36,6 +35,11 @@ Traceback (most recent call last):
 docstring_to_markdown.UnknownFormatError
 ```
 
+### Extensibility
+
+`docstring_to_markdown` entry point group allows to add custom converters which follow the `Converter` protocol.
+The built-in converters can be customized by providing entry point with matching name.
+
 ### Development
 
 ```bash
diff --git a/docstring_to_markdown/__init__.py b/docstring_to_markdown/__init__.py
index c81e124..a70ed84 100644
--- a/docstring_to_markdown/__init__.py
+++ b/docstring_to_markdown/__init__.py
@@ -1,13 +1,59 @@
-from .rst import looks_like_rst, rst_to_markdown
+from importlib_metadata import entry_points
+from typing import List, TYPE_CHECKING
 
-__version__ = "0.12"
+from .types import Converter
+
+if TYPE_CHECKING:
+    from importlib_metadata import EntryPoint
+
+__version__ = "0.17"
 
 
 class UnknownFormatError(Exception):
     pass
 
 
+def _entry_points_sort_key(entry_point: 'EntryPoint'):
+    if entry_point.dist is None:
+        return 1
+    if entry_point.dist.name == "docstring-to-markdown":
+        return 0
+    return 1
+
+
+def _load_converters() -> List[Converter]:
+    converter_entry_points = entry_points(
+        group="docstring_to_markdown"
+    )
+    # sort so that the default ones can be overridden
+    sorted_entry_points = sorted(
+        converter_entry_points,
+        key=_entry_points_sort_key
+    )
+    # de-duplicate
+    unique_entry_points = {}
+    for entry_point in sorted_entry_points:
+        unique_entry_points[entry_point.name] = entry_point
+
+    converters = []
+    for entry_point in unique_entry_points.values():
+        converter_class = entry_point.load()
+        converters.append(converter_class())
+
+    converters.sort(key=lambda converter: -converter.priority)
+
+    return converters
+
+
+_CONVERTERS = None
+
+
 def convert(docstring: str) -> str:
-    if looks_like_rst(docstring):
-        return rst_to_markdown(docstring)
+    global _CONVERTERS
+    if _CONVERTERS is None:
+        _CONVERTERS = _load_converters()
+    for converter in _CONVERTERS:
+        if converter.can_convert(docstring):
+            return converter.convert(docstring)
+
     raise UnknownFormatError()
diff --git a/docstring_to_markdown/_utils.py b/docstring_to_markdown/_utils.py
new file mode 100644
index 0000000..847c699
--- /dev/null
+++ b/docstring_to_markdown/_utils.py
@@ -0,0 +1,5 @@
+from re import sub
+
+
+def escape_markdown(text: str) -> str:
+    return sub(r'([\\#*_[\]])', r'\\\1', text)
diff --git a/docstring_to_markdown/cpython.py b/docstring_to_markdown/cpython.py
new file mode 100644
index 0000000..974ea60
--- /dev/null
+++ b/docstring_to_markdown/cpython.py
@@ -0,0 +1,60 @@
+from typing import Union, List
+from re import fullmatch
+
+from .types import Converter
+from ._utils import escape_markdown
+
+
+def _is_cpython_signature_line(line: str) -> bool:
+    """CPython uses signature lines in the following format:
+
+    str(bytes_or_buffer[, encoding[, errors]]) -> str
+    """
+    return fullmatch(r'\w+\(\S*(, \S+)*(\[, \S+\])*\)\s--?>\s.+', line) is not None
+
+
+def cpython_to_markdown(text: str) -> Union[str, None]:
+    signature_lines: List[str] = []
+    other_lines: List[str] = []
+    for line in text.splitlines():
+        if not other_lines and _is_cpython_signature_line(line):
+            signature_lines.append(line)
+        elif not signature_lines:
+            return None
+        elif line.startswith('    '):
+            signature_lines.append(line)
+        else:
+            other_lines.append(line)
+    return '\n'.join([
+        '```',
+        '\n'.join(signature_lines),
+        '```',
+        escape_markdown('\n'.join(other_lines))
+    ])
+
+
+def looks_like_cpython(text: str) -> bool:
+    return cpython_to_markdown(text) is not None
+
+
+class CPythonConverter(Converter):
+
+    priority = 10
+
+    def __init__(self) -> None:
+        self._last_docstring: Union[str, None] = None
+        self._converted: Union[str, None] = None
+
+    def can_convert(self, docstring):
+        self._last_docstring = docstring
+        self._converted = cpython_to_markdown(docstring)
+        return self._converted is not None
+
+    def convert(self, docstring):
+        if docstring != self._last_docstring:
+            self._last_docstring = docstring
+            self._converted = cpython_to_markdown(docstring)
+        return self._converted
+
+
+__all__ = ['looks_like_cpython', 'cpython_to_markdown', 'CPythonConverter']
diff --git a/docstring_to_markdown/google.py b/docstring_to_markdown/google.py
new file mode 100644
index 0000000..156f3da
--- /dev/null
+++ b/docstring_to_markdown/google.py
@@ -0,0 +1,185 @@
+import re
+from textwrap import dedent
+from typing import List
+
+from .types import Converter
+
+
+# All possible sections in Google style docstrings
+SECTION_HEADERS: List[str] = [
+    "Args",
+    "Returns",
+    "Raises",
+    "Yields",
+    "Example",
+    "Examples",
+    "Attributes",
+    "Note",
+    "Todo",
+]
+
+# These sections will not be parsed as a list of arguments/return values/etc
+PLAIN_TEXT_SECTIONS: List[str] = [
+    "Examples",
+    "Example",
+    "Note",
+    "Todo",
+]
+
+ESCAPE_RULES = {
+    # Avoid Markdown in magic methods or filenames like __init__.py
+    r"__(?P<text>\S+)__": r"\_\_\g<text>\_\_",
+}
+
+
+class Section:
+    def __init__(self, name: str, content: str) -> None:
+        self.name = name
+        self.content = ""
+
+        self._parse(content)
+
+    def _parse(self, content: str) -> None:
+        content = content.rstrip("\n")
+
+        if self.name in PLAIN_TEXT_SECTIONS:
+            self.content = dedent(content)
+            return
+
+        parts = []
+        cur_part = []
+
+        for line in content.split("\n"):
+            line = line.replace("    ", "", 1)
+
+            if line.startswith(" "):
+                # Continuation from a multiline description
+                cur_part.append(line)
+                continue
+
+            if cur_part:
+                # Leaving multiline description
+                parts.append(cur_part)
+                cur_part = [line]
+            else:
+                # Entering new description part
+                cur_part.append(line)
+
+        # Last part
+        parts.append(cur_part)
+
+        # Format section
+        for part in parts:
+            indentation = ""
+            skip_first = False
+
+            if ":" in part[0]:
+                spl = part[0].split(":")
+
+                arg = spl[0]
+                description = ":".join(spl[1:]).lstrip()
+                indentation = (len(arg) + 6) * " "
+
+                if description:
+                    self.content += "- `{}`: {}\n".format(arg, description)
+                else:
+                    skip_first = True
+                    self.content += "- `{}`: ".format(arg)
+            else:
+                self.content += "- {}\n".format(part[0])
+
+            for n, line in enumerate(part[1:]):
+                if skip_first and n == 0:
+                    # This ensures that indented args get moved to the
+                    # previous line
+                    self.content += "{}\n".format(line.lstrip())
+                    continue
+
+                self.content += "{}{}\n".format(indentation, line.lstrip())
+
+        self.content = self.content.rstrip("\n")
+
+    def as_markdown(self) -> str:
+        return "#### {}\n\n{}\n\n".format(self.name, self.content)
+
+
+class GoogleDocstring:
+    def __init__(self, docstring: str) -> None:
+        self.sections: List[Section] = []
+        self.description: str = ""
+
+        self._parse(docstring)
+
+    def _parse(self, docstring: str) -> None:
+        self.sections = []
+        self.description = ""
+
+        buf = ""
+        cur_section = ""
+
+        for line in docstring.split("\n"):
+            if is_section(line):
+                # Entering new section
+                if cur_section:
+                    # Leaving previous section, save it and reset buffer
+                    self.sections.append(Section(cur_section, buf))
+                    buf = ""
+
+                # Remember currently parsed section
+                cur_section = line.rstrip(":")
+                continue
+
+            # Parse section content
+            if cur_section:
+                buf += line + "\n"
+            else:
+                # Before setting cur_section, we're parsing the function description
+                self.description += line + "\n"
+
+        # Last section
+        self.sections.append(Section(cur_section, buf))
+
+    def as_markdown(self) -> str:
+        text = self.description
+
+        for section in self.sections:
+            text += section.as_markdown()
+
+        return text.rstrip("\n") + "\n"  # Only keep one last newline
+
+
+def is_section(line: str) -> bool:
+    for section in SECTION_HEADERS:
+        if re.search(r"{}:".format(section), line):
+            return True
+
+    return False
+
+
+def looks_like_google(value: str) -> bool:
+    for section in SECTION_HEADERS:
+        if re.search(r"{}:\n".format(section), value):
+            return True
+
+    return False
+
+
+def google_to_markdown(text: str, extract_signature: bool = True) -> str:
+    # Escape parts we don't want to render
+    for pattern, replacement in ESCAPE_RULES.items():
+        text = re.sub(pattern, replacement, text)
+
+    docstring = GoogleDocstring(text)
+
+    return docstring.as_markdown()
+
+
+class GoogleConverter(Converter):
+
+    priority = 75
+
+    def can_convert(self, docstring):
+        return looks_like_google(docstring)
+
+    def convert(self, docstring):
+        return google_to_markdown(docstring)
diff --git a/docstring_to_markdown/plain.py b/docstring_to_markdown/plain.py
new file mode 100644
index 0000000..3c42253
--- /dev/null
+++ b/docstring_to_markdown/plain.py
@@ -0,0 +1,40 @@
+from re import fullmatch
+from .types import Converter
+from ._utils import escape_markdown
+
+
+def looks_like_plain_text(value: str) -> bool:
+    """Check if given string has plain text following English syntax without need for escaping.
+
+    Accepts:
+    - words without numbers
+    - full stop, bangs and question marks at the end of a word if followed by a space or end of string
+    - commas, colons and semicolons if after a word and followed by a space
+    - dashes between words (like in `e-mail`)
+    - double and single quotes if proceeded with a space and followed by a word, or if proceeded by a word and followed by a space (or end of string); single quotes are also allowed in between two words
+    - parentheses if opening preceded by space and closing followed by space or end
+
+    Does not accept:
+    - square brackets (used in markdown a lot)
+    """
+    if '_' in value:
+        return False
+    return fullmatch(r"((\w[\.!\?\)'\"](\s|$))|(\w[,:;]\s)|(\w[-']\w)|(\w\s['\"\(])|\w|\s)+", value) is not None
+
+
+def plain_text_to_markdown(text: str) -> str:
+    return escape_markdown(text)
+
+
+class PlainTextConverter(Converter):
+
+    priority = 50
+
+    def can_convert(self, docstring):
+        return looks_like_plain_text(docstring)
+
+    def convert(self, docstring):
+        return plain_text_to_markdown(docstring)
+
+
+__all__ = ['looks_like_plain_text', 'plain_text_to_markdown', 'PlainTextConverter']
diff --git a/docstring_to_markdown/rst.py b/docstring_to_markdown/rst.py
index 174f9de..040b26d 100644
--- a/docstring_to_markdown/rst.py
+++ b/docstring_to_markdown/rst.py
@@ -1,13 +1,16 @@
 from abc import ABC, abstractmethod
 from enum import IntEnum, auto
+from textwrap import dedent
 from types import SimpleNamespace
-from typing import Union, List, Dict
+from typing import Callable, Match, Union, List, Dict
 import re
 
+from .types import Converter
+
 
 class Directive:
     def __init__(
-        self, pattern: str, replacement: str,
+        self, pattern: str, replacement: Union[str, Callable[[Match], str]],
         name: Union[str, None] = None,
         flags: int = 0
     ):
@@ -249,7 +252,7 @@ def inline_markdown(self):
     ),
     Directive(
         pattern=r'`(?P<label>[^<`]+?)(\n?)<(?P<url>[^>`]+)>`_+',
-        replacement=r'[\g<label>](\g<url>)'
+        replacement=lambda m: '[' + m.group('label') + '](' + re.sub(r"\s+", "", m.group('url')) + ')'
     ),
     Directive(
         pattern=r':mod:`(?P<label>[^`]+)`',
@@ -297,8 +300,8 @@ def inline_markdown(self):
 SECTION_DIRECTIVES: Dict[str, List[Directive]] = {
     'Parameters': [
         Directive(
-            pattern=r'^(?P<other_args>\*\*kwargs|\*args)$',
-            replacement=r'- `\g<other_args>`'
+            pattern=r'^(?P<other_args>(\w[\w\d_\.]*)|\*\*kwargs|\*args)$',
+            replacement=r'- `\g<other_args>`:'
         ),
         Directive(
             pattern=r'^(?P<arg1>[^:\s]+\d), (?P<arg2>[^:\s]+\d), \.\.\. : (?P<type>.+)$',
@@ -316,7 +319,7 @@ def inline_markdown(self):
 
 ESCAPING_RULES: List[Directive] = [
     Directive(
-        pattern=r'__(?P<text>\S+)__',
+        pattern=r'(?<!`)__(?P<text>\S+)__(?!`)',
         replacement=r'\_\_\g<text>\_\_'
     )
 ]
@@ -334,6 +337,7 @@ def _find_directive_pattern(name: str):
 
 
 def looks_like_rst(value: str) -> bool:
+    value = dedent(value)
     # check if any of the characteristic sections (and the properly formatted underline) is there
     for section in _RST_SECTIONS:
         if (section + '\n' + '-' * len(section) + '\n') in value:
@@ -532,7 +536,7 @@ def _consume_row(self, line: str):
                 self._rows.append(self._split(line))
             self._expecting_row_content = not self._expecting_row_content
         else:
-            self._state += 1
+            self._state += 1    # pragma: no cover
 
 
 class BlockParser(IParser):
@@ -540,10 +544,20 @@ class BlockParser(IParser):
     follower: Union['IParser', None] = None
     _buffer: List[str]
     _block_started: bool
+    _indent: Union[int, None]
+    should_measure_indent = True
 
     def __init__(self):
         self._buffer = []
         self._block_started = False
+        self._indent = None
+
+    def measure_indent(self, line: str):
+        line_indent = len(line) - len(line.lstrip())
+        if self._indent is None:
+            self._indent = line_indent
+        else:
+            self._indent = min(line_indent, self._indent)
 
     @abstractmethod
     def can_parse(self, line: str) -> bool:
@@ -556,6 +570,8 @@ def _start_block(self, language: str):
     def consume(self, line: str):
         if not self._block_started:
             raise ValueError('Block has not started')   # pragma: no cover
+        if self.should_measure_indent:
+            self.measure_indent(line)
         self._buffer.append(line)
 
     def finish_consumption(self, final: bool) -> str:
@@ -563,17 +579,24 @@ def finish_consumption(self, final: bool) -> str:
         if self._buffer[len(self._buffer) - 1].strip() == '':
             self._buffer.pop()
         self._buffer.append(self.enclosure + '\n')
-        result = '\n'.join(self._buffer)
+        indent = " " * (self._indent or 0)
+        intermediate = '\n'.join(self._buffer)
+        result = '\n'.join([
+            (indent + line) if line else line
+            for line in intermediate.splitlines()
+        ]) if indent else intermediate
         if not final:
             result += '\n'
         self._buffer = []
         self._block_started = False
+        self._indent = None
         return result
 
 
 class IndentedBlockParser(BlockParser, ABC):
     _is_block_beginning: bool
     _block_indent_size: Union[int, None]
+    should_measure_indent = False
 
     def __init__(self):
         super(IndentedBlockParser, self).__init__()
@@ -597,6 +620,7 @@ def consume(self, line: str):
                 return
         if self._block_indent_size is None:
             self._block_indent_size = len(line) - len(line.lstrip())
+        self.measure_indent(line)
         super().consume(line[self._block_indent_size:])
 
     def finish_consumption(self, final: bool) -> str:
@@ -651,11 +675,13 @@ def initiate_parsing(self, line: str, current_language: str):
         if line.strip() == '.. autosummary::':
             language = ''
             line = ''
+            suffix = ''
         else:
             line = re.sub(r'::$', '', line)
+            suffix = '\n\n'
 
         self._start_block(language)
-        return IBlockBeginning(remainder=line.rstrip() + '\n\n')
+        return IBlockBeginning(remainder=line.rstrip() + suffix)
 
 
 class MathBlockParser(IndentedBlockParser):
@@ -680,6 +706,7 @@ def can_parse(self, line: str):
         return line.strip() in self.directives
 
     def initiate_parsing(self, line: str, current_language: str):
+        self.measure_indent(line)
         admonition = self.directives[line.strip()]
         self._start_block(f'\n{admonition.block_markdown}\n')
         return IBlockBeginning(remainder='')
@@ -690,6 +717,7 @@ def can_parse(self, line: str) -> bool:
         return re.match(CODE_BLOCK_PATTERN, line) is not None
 
     def initiate_parsing(self, line: str, current_language: str) -> IBlockBeginning:
+        self.measure_indent(line)
         match = re.match(CODE_BLOCK_PATTERN, line)
         # already checked in can_parse
         assert match
@@ -749,6 +777,8 @@ def rst_to_markdown(text: str, extract_signature: bool = True) -> str:
     most_recent_section: Union[str, None] = None
     is_first_line = True
 
+    text = dedent(text)
+
     def flush_buffer():
         nonlocal lines_buffer
         lines = '\n'.join(lines_buffer)
@@ -762,7 +792,8 @@ def flush_buffer():
         lines_buffer = []
         return lines
 
-    for line in text.split('\n'):
+    lines = text.split('\n')
+    for i, line in enumerate(lines):
         if is_first_line:
             if extract_signature:
                 signature_match = re.match(r'^(?P<name>\S+)\((?P<params>.*)\)$', line)
@@ -805,7 +836,9 @@ def flush_buffer():
             else:
                 if most_recent_section in SECTION_DIRECTIVES:
                     for section_directive in SECTION_DIRECTIVES[most_recent_section]:
-                        if re.match(section_directive.pattern, trimmed_line):
+                        next_line = lines[i + 1] if i + 1 < len(lines) else ""
+                        is_next_line_section = set(next_line.strip()) == {"-"}
+                        if re.match(section_directive.pattern, line) and not is_next_line_section:
                             line = re.sub(section_directive.pattern, section_directive.replacement, trimmed_line)
                             break
                 if trimmed_line.rstrip() in RST_SECTIONS:
@@ -825,3 +858,14 @@ def flush_buffer():
     if active_parser:
         markdown += active_parser.finish_consumption(True)
     return markdown
+
+
+class ReStructuredTextConverter(Converter):
+
+    priority = 100
+
+    def can_convert(self, docstring):
+        return looks_like_rst(docstring)
+
+    def convert(self, docstring):
+        return rst_to_markdown(docstring)
diff --git a/docstring_to_markdown/types.py b/docstring_to_markdown/types.py
new file mode 100644
index 0000000..ef7fb18
--- /dev/null
+++ b/docstring_to_markdown/types.py
@@ -0,0 +1,14 @@
+from typing_extensions import Protocol
+
+
+class Converter(Protocol):
+
+    def convert(self, docstring: str) -> str:
+        """Convert given docstring to markdown."""
+
+    def can_convert(self, docstring: str) -> bool:
+        """Check if conversion to markdown can be performed."""
+
+    # The higher the priority, the sooner the conversion
+    # with this converter will be attempted.
+    priority: int
diff --git a/pyproject.toml b/pyproject.toml
new file mode 100644
index 0000000..fed528d
--- /dev/null
+++ b/pyproject.toml
@@ -0,0 +1,3 @@
+[build-system]
+requires = ["setuptools"]
+build-backend = "setuptools.build_meta"
diff --git a/requirements-dev.txt b/requirements-dev.txt
index 76d0c2c..d6df770 100644
--- a/requirements-dev.txt
+++ b/requirements-dev.txt
@@ -1,5 +1,5 @@
 pytest
 pytest-cov
 pytest-flake8
-flake8<5
+flake8
 mypy
diff --git a/setup.cfg b/setup.cfg
index 4b48e64..817ea9e 100644
--- a/setup.cfg
+++ b/setup.cfg
@@ -28,21 +28,36 @@ warn_unused_configs = True
 
 [options]
 packages = find:
-python_requires = >=3.6
+python_requires = >=3.7
+install_requires =
+    importlib-metadata>=3.6
+    typing_extensions>=4.6
 
 [options.package_data]
 docstring-to-markdown = py.typed
 
+[options.entry_points]
+docstring_to_markdown =
+  rst = docstring_to_markdown.rst:ReStructuredTextConverter
+  google = docstring_to_markdown.google:GoogleConverter
+  plain = docstring_to_markdown.plain:PlainTextConverter
+  cpython = docstring_to_markdown.cpython:CPythonConverter
+
 [tool:pytest]
 addopts =
     --pyargs tests
     --cov docstring_to_markdown
-    --cov-fail-under=98
+    --cov-fail-under=100
     --cov-report term-missing:skip-covered
     -p no:warnings
     --flake8
     -vv
 
+[coverage:report]
+exclude_lines =
+    pragma: no cover
+    if TYPE_CHECKING:
+
 [flake8]
 max-line-length = 120
 max-complexity = 15
diff --git a/tests/test_convert.py b/tests/test_convert.py
new file mode 100644
index 0000000..725951f
--- /dev/null
+++ b/tests/test_convert.py
@@ -0,0 +1,132 @@
+from contextlib import contextmanager
+from docstring_to_markdown import convert, UnknownFormatError
+from docstring_to_markdown.types import Converter
+from docstring_to_markdown.cpython import CPythonConverter
+from importlib_metadata import EntryPoint, entry_points, distribution
+from unittest.mock import patch
+import docstring_to_markdown
+import pytest
+
+CPYTHON = """\
+bool(x) -> bool
+
+Returns True when the argument x is true, False otherwise.\
+"""
+
+
+CPYTHON_MD = """\
+```
+bool(x) -> bool
+```
+
+Returns True when the argument x is true, False otherwise.\
+"""
+
+GOOGLE = """Do **something**.
+
+Args:
+    a: some arg
+    b: some arg
+"""
+
+GOOGLE_MD = """Do **something**.
+
+#### Args
+
+- `a`: some arg
+- `b`: some arg
+"""
+
+
+RST = "Please see `this link<https://example.com>`__."
+RST_MD = "Please see [this link](https://example.com)."
+
+
+def test_convert_cpython():
+    assert convert(CPYTHON) == CPYTHON_MD
+
+
+def test_convert_plain_text():
+    assert convert('This is a sentence.') == 'This is a sentence.'
+
+
+def test_convert_google():
+    assert convert(GOOGLE) == GOOGLE_MD
+
+
+def test_convert_rst():
+    assert convert(RST) == RST_MD
+
+
+def test_unknown_format():
+    with pytest.raises(UnknownFormatError):
+        convert('ARGS [arg1, arg2] RETURNS: str OR None')
+
+
+class HighPriorityConverter(Converter):
+    priority = 120
+
+    def convert(self, docstring):
+        return "HighPriority"
+
+    def can_convert(self, docstring):
+        return True
+
+
+class MockEntryPoint(EntryPoint):
+    def load(self):
+        return globals()[self.attr]
+
+    dist = None
+
+
+class DistMockEntryPoint(MockEntryPoint):
+    # Pretend it is contributed by `pytest`.
+    # It could be anything else, but `pytest`
+    # is guaranteed to be installed during tests.
+    dist = distribution('pytest')
+
+
+class CustomCPythonConverter(CPythonConverter):
+    priority = 10
+
+    def convert(self, docstring):
+        return 'CustomCPython'
+
+    def can_convert(self, docstring):
+        return True
+
+
+@contextmanager
+def custom_entry_points(entry_points):
+    old = docstring_to_markdown._CONVERTERS
+    docstring_to_markdown._CONVERTERS = None
+    with patch.object(docstring_to_markdown, 'entry_points', return_value=entry_points):
+        yield
+    docstring_to_markdown._CONVERTERS = old
+
+
+def test_adding_entry_point():
+    original_entry_points = entry_points(group="docstring_to_markdown")
+    mock_entry_point = MockEntryPoint(
+        name='high-priority-converter',
+        group='docstring_to_markdown',
+        value="here:HighPriorityConverter",
+    )
+    with custom_entry_points([*original_entry_points, mock_entry_point]):
+        assert convert('test') == 'HighPriority'
+
+
+def test_replacing_entry_point():
+    assert convert(CPYTHON) == CPYTHON_MD
+    original_entry_points = entry_points(group="docstring_to_markdown")
+    mock_entry_point = DistMockEntryPoint(
+        name='cpython',
+        group='docstring_to_markdown',
+        value="here:CustomCPythonConverter",
+    )
+    with custom_entry_points([*original_entry_points, mock_entry_point]):
+        assert convert('test') == 'test'
+        assert convert(GOOGLE) == GOOGLE_MD
+        assert convert(RST) == RST_MD
+        assert convert(CPYTHON) == 'CustomCPython'
diff --git a/tests/test_cpython.py b/tests/test_cpython.py
new file mode 100644
index 0000000..b292c66
--- /dev/null
+++ b/tests/test_cpython.py
@@ -0,0 +1,110 @@
+import pytest
+from docstring_to_markdown.cpython import looks_like_cpython, cpython_to_markdown, CPythonConverter
+
+BOOL = """\
+bool(x) -> bool
+
+Returns True when the argument x is true, False otherwise.\
+"""
+
+BOOL_MD = """\
+```
+bool(x) -> bool
+```
+
+Returns True when the argument x is true, False otherwise.\
+"""
+
+BYTES = """\
+bytes(iterable_of_ints) -> bytes
+bytes(string, encoding[, errors]) -> bytes
+bytes(bytes_or_buffer) -> immutable copy of bytes_or_buffer
+bytes(int) -> bytes object of size given by the parameter initialized with null bytes
+bytes() -> empty bytes object
+
+Construct an immutable array of bytes from:
+  - an iterable yielding integers in range(256)
+  - a text string encoded using the specified encoding
+  - any object implementing the buffer API.
+  - an integer\
+"""
+
+COLLECTIONS_DEQUEUE = """\
+deque([iterable[, maxlen]]) --> deque object
+
+A list-like sequence optimized for data accesses near its endpoints.\
+"""
+
+DICT = """\
+dict() -> new empty dictionary
+dict(mapping) -> new dictionary initialized from a mapping object's
+    (key, value) pairs
+dict(iterable) -> new dictionary initialized as if via:
+    d = {}
+    for k, v in iterable:
+        d[k] = v
+dict(**kwargs) -> new dictionary initialized with the name=value pairs
+    in the keyword argument list.  For example:  dict(one=1, two=2)\
+"""
+
+STR = """\
+str(object='') -> str
+str(bytes_or_buffer[, encoding[, errors]]) -> str
+
+Create a new string object from the given object. If encoding or
+errors is specified, then the object must expose a data buffer
+that will be decoded using the given encoding and error handler.
+Otherwise, returns the result of object.__str__() (if defined)
+or repr(object).\
+"""
+
+STR_MD = """\
+```
+str(object='') -> str
+str(bytes_or_buffer[, encoding[, errors]]) -> str
+```
+
+Create a new string object from the given object. If encoding or
+errors is specified, then the object must expose a data buffer
+that will be decoded using the given encoding and error handler.
+Otherwise, returns the result of object.\\_\\_str\\_\\_() (if defined)
+or repr(object).\
+"""
+
+
+@pytest.mark.parametrize("text", [BYTES, STR, DICT, BOOL, COLLECTIONS_DEQUEUE])
+def test_accepts_cpython_docstrings(text):
+    assert looks_like_cpython(text) is True
+
+
+@pytest.mark.parametrize("text", [
+    "[link label](https://link)",
+    "![image label](https://source)",
+    "Some **bold** text",
+    "More __bold__ text",
+    "Some *italic* text",
+    "More _italic_ text",
+    "This is a sentence.",
+    "Exclamation!",
+    "Can I ask a question?",
+    "Let's send an e-mail",
+    "Parentheses (are) fine (really)",
+    "Double \"quotes\" and single 'quotes'"
+])
+def test_rejects_markdown_and_plain_text(text):
+    assert looks_like_cpython(text) is False
+
+
+def test_conversion_bool():
+    assert cpython_to_markdown(BOOL) == BOOL_MD
+
+
+def test_conversion_str():
+    assert cpython_to_markdown(STR) == STR_MD
+
+
+def test_convert():
+    converter = CPythonConverter()
+    assert converter.can_convert(BOOL)
+    assert not converter.can_convert('this is plain text')
+    assert converter.convert(BOOL) == BOOL_MD
diff --git a/tests/test_google.py b/tests/test_google.py
new file mode 100644
index 0000000..ef0d785
--- /dev/null
+++ b/tests/test_google.py
@@ -0,0 +1,142 @@
+import pytest
+
+from docstring_to_markdown.google import google_to_markdown, looks_like_google, GoogleConverter
+
+BASIC_EXAMPLE = """Do **something**.
+
+Some more detailed description.
+
+Args:
+    a: some arg
+    b: some arg
+
+Returns:
+    Same *stuff*
+"""
+
+BASIC_EXAMPLE_MD = """Do **something**.
+
+Some more detailed description.
+
+#### Args
+
+- `a`: some arg
+- `b`: some arg
+
+#### Returns
+
+- Same *stuff*
+"""
+
+ESCAPE_MAGIC_METHOD = """Example.
+
+Args:
+    a: see __init__.py
+"""
+
+ESCAPE_MAGIC_METHOD_MD = """Example.
+
+#### Args
+
+- `a`: see \\_\\_init\\_\\_.py
+"""
+
+PLAIN_SECTION = """Example.
+
+Args:
+    a: some arg
+
+Note:
+    Do not use this.
+
+Example:
+    Do it like this.
+"""
+
+PLAIN_SECTION_MD = """Example.
+
+#### Args
+
+- `a`: some arg
+
+#### Note
+
+Do not use this.
+
+#### Example
+
+Do it like this.
+"""
+
+MULTILINE_ARG_DESCRIPTION = """Example.
+
+Args:
+    a (str): This is a long description
+             spanning over several lines
+        also with broken indentation
+    b (str): Second arg
+    c (str):
+        On the next line
+        And also multiple lines
+"""
+
+MULTILINE_ARG_DESCRIPTION_MD = """Example.
+
+#### Args
+
+- `a (str)`: This is a long description
+             spanning over several lines
+             also with broken indentation
+- `b (str)`: Second arg
+- `c (str)`: On the next line
+             And also multiple lines
+"""
+
+GOOGLE_CASES = {
+    "basic example": {
+        "google": BASIC_EXAMPLE,
+        "md": BASIC_EXAMPLE_MD,
+    },
+    "escape magic method": {
+        "google": ESCAPE_MAGIC_METHOD,
+        "md": ESCAPE_MAGIC_METHOD_MD,
+    },
+    "plain section": {
+        "google": PLAIN_SECTION,
+        "md": PLAIN_SECTION_MD,
+    },
+    "multiline arg description": {
+        "google": MULTILINE_ARG_DESCRIPTION,
+        "md": MULTILINE_ARG_DESCRIPTION_MD,
+    },
+}
+
+
+@pytest.mark.parametrize(
+    "google",
+    [case["google"] for case in GOOGLE_CASES.values()],
+    ids=GOOGLE_CASES.keys(),
+)
+def test_looks_like_google_recognises_google(google):
+    assert looks_like_google(google)
+
+
+def test_looks_like_google_ignores_plain_text():
+    assert not looks_like_google("This is plain text")
+    assert not looks_like_google("See Also\n--------\n")
+
+
+@pytest.mark.parametrize(
+    "google,markdown",
+    [[case["google"], case["md"]] for case in GOOGLE_CASES.values()],
+    ids=GOOGLE_CASES.keys(),
+)
+def test_google_to_markdown(google, markdown):
+    assert google_to_markdown(google) == markdown
+
+
+def test_converter():
+    converter = GoogleConverter()
+    assert converter.can_convert(BASIC_EXAMPLE)
+    assert not converter.can_convert("This is plain text")
+    assert converter.convert(BASIC_EXAMPLE) == BASIC_EXAMPLE_MD
diff --git a/tests/test_plain.py b/tests/test_plain.py
new file mode 100644
index 0000000..0e30eef
--- /dev/null
+++ b/tests/test_plain.py
@@ -0,0 +1,49 @@
+import pytest
+from docstring_to_markdown.plain import looks_like_plain_text, plain_text_to_markdown, PlainTextConverter
+
+
+@pytest.mark.parametrize("text", [
+    "This is a sentence.",
+    "Exclamation!",
+    "Can I ask a question?",
+    "Let's send an e-mail",
+    "Parentheses (are) fine (really)",
+    "Double \"quotes\" and single 'quotes'"
+])
+def test_accepts_english(text):
+    assert looks_like_plain_text(text) is True
+
+
+@pytest.mark.parametrize("text", [
+    "[link label](https://link)",
+    "![image label](https://source)",
+    "Some **bold** text",
+    "More __bold__ text",
+    "Some *italic* text",
+    "More _italic_ text"
+])
+def test_rejects_markdown(text):
+    assert looks_like_plain_text(text) is False
+
+
+@pytest.mark.parametrize("text", [
+    "def test():",
+    "print(123)",
+    "func(arg)",
+    "2 + 2",
+    "var['test']",
+    "x = 'test'"
+])
+def test_rejects_code(text):
+    assert looks_like_plain_text(text) is False
+
+
+def test_conversion():
+    assert plain_text_to_markdown("test") == "test"
+
+
+def test_convert():
+    converter = PlainTextConverter()
+    assert not converter.can_convert('def test():')
+    assert converter.can_convert('this is plain text')
+    assert converter.convert('test') == 'test'
diff --git a/tests/test_rst.py b/tests/test_rst.py
index 93f89ac..4bafe26 100644
--- a/tests/test_rst.py
+++ b/tests/test_rst.py
@@ -1,6 +1,6 @@
 import pytest
 
-from docstring_to_markdown.rst import looks_like_rst, rst_to_markdown
+from docstring_to_markdown.rst import looks_like_rst, rst_to_markdown, ReStructuredTextConverter
 
 
 SEE_ALSO = """
@@ -78,6 +78,17 @@
     "[this link](https://pandas.pydata.org/pandas-docs/stable/user_guide/timeseries.html#offset-aliases)."
 )
 
+RST_LINK_MULTILINE_EXAMPLE = """
+See
+`strftime documentation
+<https://docs.python.org/3/library/datetime.html
+#strftime-and-strptime-behavior>`_ for more.
+"""
+RST_LINK_MULTILINE_MARKDOWN = """
+See
+[strftime documentation](https://docs.python.org/3/library/datetime.html#strftime-and-strptime-behavior) for more.
+"""
+
 RST_REF_EXAMPLE = """See :ref:`here <timeseries.offset_aliases>` for a list of frequency aliases."""
 RST_REF_MARKDOWN = """See here: `timeseries.offset_aliases` for a list of frequency aliases."""
 
@@ -108,6 +119,26 @@
 A function definition is an executable statement.
 """
 
+RST_AUTOSUMMARY_BLOCK = """
+Summary
+
+.. autosummary::
+
+   environment.BuildEnvironment
+   util.relative_uri
+"""
+
+
+RST_AUTOSUMMARY_BLOCK_MARKDOWN = """
+Summary
+
+```
+environment.BuildEnvironment
+util.relative_uri
+```
+"""
+
+
 RST_COLON_CODE_BLOCK = """
 For example, the following code ::
 
@@ -306,7 +337,7 @@ def func(): pass
 
 - `x`: array_like
     Input array.
-- `**kwargs`
+- `**kwargs`:
     For other keyword-only arguments, see the ufunc docs.
 """
 
@@ -587,6 +618,139 @@ def func(): pass
 """
 
 
+BROKEN_GRID_TABLE = """
++------------+-----------+------------+-----------------+---+---------+
+|param_kernel|param_gamma|param_degree|split0_test_score|...|rank_t...|
++============+===========+============+=================+===+=========+
+|  'poly'    |     --    |      2     |       0.80      |...|    2    |
++------------+-----------+------------+-----------------+---+---------+
+|  'poly'    |     --    |      3     |       0.70      |...|    4    |
+someone forgot to close the row above.
+"""
+
+
+BROKEN_GRID_TABLE_MARKDOWN = """
+| param_kernel | param_gamma | param_degree | split0_test_score | ... | rank_t... |
+| ------------ | ----------- | ------------ | ----------------- | --- | --------- |
+| 'poly'       | --          | 2            | 0.80              | ... | 2         |
+| 'poly'       | --          | 3            | 0.70              | ... | 4         |
+someone forgot to close the row above.
+"""
+
+
+# this format is often used by polars
+PARAMETERS_WITHOUT_TYPE = """
+Parameters
+----------
+source
+    Path(s) to a file or directory
+    When needing to authenticate for scanning cloud locations, see the
+    `storage_options` parameter.
+columns
+    Columns to select. Accepts a list of column indices (starting at zero) or a list
+    of column names.
+n_rows
+    Stop reading from parquet file after reading `n_rows`.
+    Only valid when `use_pyarrow=False`.
+
+Returns
+-------
+DataFrame
+"""
+
+PARAMETERS_WITHOUT_TYPE_MARKDOWN = """
+#### Parameters
+
+- `source`:
+    Path(s) to a file or directory
+    When needing to authenticate for scanning cloud locations, see the
+    `storage_options` parameter.
+- `columns`:
+    Columns to select. Accepts a list of column indices (starting at zero) or a list
+    of column names.
+- `n_rows`:
+    Stop reading from parquet file after reading `n_rows`.
+    Only valid when `use_pyarrow=False`.
+
+#### Returns
+
+DataFrame
+"""
+
+INDENTED_DOCSTRING = """
+    Parameters
+    ----------
+    glob
+        Expand path given via globbing rules.
+"""
+
+INDENTED_DOCSTRING_MARKDOWN = """
+#### Parameters
+
+- `glob`:
+    Expand path given via globbing rules.
+"""
+
+
+WARNINGS_IN_PARAMETERS = """
+Parameters
+----------
+glob
+    Expand path given via globbing rules.
+schema
+    Specify the datatypes of the columns. The datatypes must match the
+    datatypes in the file(s). If there are extra columns that are not in the
+    file(s), consider also enabling `allow_missing_columns`.
+
+    .. warning::
+        This functionality is considered **unstable**. It may be changed
+        at any point without it being considered a breaking change.
+hive_schema
+    The column names and data types of the columns by which the data is partitioned.
+    If set to `None` (default), the schema of the Hive partitions is inferred.
+
+    .. warning::
+        This functionality is considered **unstable**. It may be changed
+        at any point without it being considered a breaking change.
+try_parse_hive_dates
+    Whether to try parsing hive values as date/datetime types.
+"""
+
+
+WARNINGS_IN_PARAMETERS_MARKDOWN = """
+#### Parameters
+
+- `glob`:
+    Expand path given via globbing rules.
+- `schema`:
+    Specify the datatypes of the columns. The datatypes must match the
+    datatypes in the file(s). If there are extra columns that are not in the
+    file(s), consider also enabling `allow_missing_columns`.
+
+
+    ---
+    ⚠️  **Warning**
+
+    This functionality is considered **unstable**. It may be changed
+    at any point without it being considered a breaking change.
+
+    ---
+- `hive_schema`:
+    The column names and data types of the columns by which the data is partitioned.
+    If set to `None` (default), the schema of the Hive partitions is inferred.
+
+
+    ---
+    ⚠️  **Warning**
+
+    This functionality is considered **unstable**. It may be changed
+    at any point without it being considered a breaking change.
+
+    ---
+- `try_parse_hive_dates`:
+    Whether to try parsing hive values as date/datetime types.
+"""
+
 NESTED_PARAMETERS = """
 Parameters
 ----------
@@ -686,6 +850,10 @@ def foo():
         'rst': RST_LINK_EXAMPLE,
         'md': RST_LINK_EXAMPLE_MARKDOWN
     },
+    'converts multi-line links': {
+        'rst': RST_LINK_MULTILINE_EXAMPLE,
+        'md': RST_LINK_MULTILINE_MARKDOWN
+    },
     'changes highlight': {
         'rst': RST_HIGHLIGHTED_BLOCK,
         'md': RST_HIGHLIGHTED_BLOCK_MARKDOWN
@@ -718,6 +886,10 @@ def foo():
         'rst': NUMPY_EXAMPLE,
         'md': NUMPY_EXAMPLE_MARKDOWN
     },
+    'converts autosummary block': {
+        'rst': RST_AUTOSUMMARY_BLOCK,
+        'md': RST_AUTOSUMMARY_BLOCK_MARKDOWN
+    },
     'converts version changed': {
         'rst': '.. versionchanged:: 0.23.0',
         'md': '*Changed in 0.23.0*'
@@ -764,6 +936,10 @@ def foo():
         'rst': '__init__',
         'md': r'\_\_init\_\_'
     },
+    'does not escape dunders in code': {
+        'rst': '`__init__`',
+        'md': '`__init__`'
+    },
     'converts bibliographic references': {
         'rst': REFERENCES,
         'md': REFERENCES_MARKDOWN
@@ -816,10 +992,26 @@ def foo():
         'rst': GRID_TABLE_IN_SKLEARN,
         'md': GRID_TABLE_IN_SKLEARN_MARKDOWN
     },
+    'converts broken grid table': {
+        'rst': BROKEN_GRID_TABLE,
+        'md': BROKEN_GRID_TABLE_MARKDOWN
+    },
     'converts nested parameter lists': {
         'rst': NESTED_PARAMETERS,
         'md': NESTED_PARAMETERS_MARKDOWN
     },
+    'converts parameter without type': {
+        'rst': PARAMETERS_WITHOUT_TYPE,
+        'md': PARAMETERS_WITHOUT_TYPE_MARKDOWN
+    },
+    'converts indented parameters lists': {
+        'rst': INDENTED_DOCSTRING,
+        'md': INDENTED_DOCSTRING_MARKDOWN
+    },
+    'converts warnings in parameters lists': {
+        'rst': WARNINGS_IN_PARAMETERS,
+        'md': WARNINGS_IN_PARAMETERS_MARKDOWN
+    },
     'converts sphinx signatures': {
         'rst': SPHINX_SIGNATURE,
         'md': SPHINX_SIGNATURE_MARKDOWN
@@ -869,3 +1061,10 @@ def test_rst_to_markdown(rst, markdown):
     converted = rst_to_markdown(rst)
     print(converted)
     assert converted == markdown
+
+
+def test_converter():
+    converter = ReStructuredTextConverter()
+    assert converter.can_convert('.. versionadded:: 0.1')
+    assert not converter.can_convert('this is plain text')
+    assert converter.convert(PEP_287_CODE_BLOCK) == PEP_287_CODE_BLOCK_MARKDOWN