diff --git a/ci/deps/actions-38-db-min.yaml b/ci/deps/actions-38-db-min.yaml
index c93f791b7dba7..55489a41f7997 100644
--- a/ci/deps/actions-38-db-min.yaml
+++ b/ci/deps/actions-38-db-min.yaml
@@ -15,6 +15,7 @@ dependencies:
   - numpy<1.20  # GH#39541 compat for pyarrow<3
   - python-dateutil
   - pytz
+  - jinja2
 
   # optional
   - beautifulsoup4
diff --git a/ci/deps/actions-38-db.yaml b/ci/deps/actions-38-db.yaml
index b4495fa6887f4..d6c37cf62dad8 100644
--- a/ci/deps/actions-38-db.yaml
+++ b/ci/deps/actions-38-db.yaml
@@ -20,6 +20,7 @@ dependencies:
   - gcsfs>=0.6.0
   - geopandas
   - html5lib
+  - jinja2
   - matplotlib
   - moto>=1.3.14
   - flask
diff --git a/ci/deps/actions-38-locale_slow.yaml b/ci/deps/actions-38-locale_slow.yaml
index e7276027f2a41..b55cc935e131d 100644
--- a/ci/deps/actions-38-locale_slow.yaml
+++ b/ci/deps/actions-38-locale_slow.yaml
@@ -28,3 +28,4 @@ dependencies:
   - xlsxwriter=1.2.2
   - xlwt=1.3.0
   - html5lib=1.1
+  - jinja2
diff --git a/ci/deps/actions-38-slow.yaml b/ci/deps/actions-38-slow.yaml
index 08900a31fe27c..39fe7ea7b086a 100644
--- a/ci/deps/actions-38-slow.yaml
+++ b/ci/deps/actions-38-slow.yaml
@@ -36,3 +36,4 @@ dependencies:
   - moto
   - flask
   - numba
+  - jinja2
diff --git a/ci/deps/actions-38.yaml b/ci/deps/actions-38.yaml
index 86b038ff7d4b6..273d9e2d016ae 100644
--- a/ci/deps/actions-38.yaml
+++ b/ci/deps/actions-38.yaml
@@ -18,3 +18,4 @@ dependencies:
   - nomkl
   - pytz
   - tabulate==0.8.7
+  - jinja2
diff --git a/ci/deps/actions-39-numpydev.yaml b/ci/deps/actions-39-numpydev.yaml
index 03181a9d71d1d..18fe197eb0a24 100644
--- a/ci/deps/actions-39-numpydev.yaml
+++ b/ci/deps/actions-39-numpydev.yaml
@@ -13,6 +13,7 @@ dependencies:
   # pandas dependencies
   - python-dateutil
   - pytz
+  - jinja2
   - pip
   - pip:
     - cython==0.29.21 # GH#34014
diff --git a/doc/source/getting_started/install.rst b/doc/source/getting_started/install.rst
index 20ae37c85a9d9..99b96b62e314e 100644
--- a/doc/source/getting_started/install.rst
+++ b/doc/source/getting_started/install.rst
@@ -227,6 +227,7 @@ Package                                                          Minimum support
 `NumPy <https://numpy.org>`__                                    1.18.5
 `python-dateutil <https://dateutil.readthedocs.io/en/stable/>`__ 2.8.1
 `pytz <https://pypi.org/project/pytz/>`__                        2020.1
+`Jinja2 <https://jinja.pocoo.org>`__                             2.11
 ================================================================ ==========================
 
 .. _install.recommended_dependencies:
@@ -266,7 +267,6 @@ Visualization
 Dependency                Minimum Version    Notes
 ========================= ================== =============================================================
 matplotlib                3.3.2              Plotting library
-Jinja2                    2.11               Conditional formatting with DataFrame.style
 tabulate                  0.8.7              Printing in Markdown-friendly format (see `tabulate`_)
 ========================= ================== =============================================================
 
diff --git a/environment.yml b/environment.yml
index 733bd06fbe12f..2199dd690d828 100644
--- a/environment.yml
+++ b/environment.yml
@@ -7,6 +7,7 @@ dependencies:
   - python=3.8
   - python-dateutil>=2.8.1
   - pytz
+  - jinja2  # pandas.Styler (DataFrame.to_html / to_latex)
 
   # benchmarks
   - asv
@@ -79,7 +80,6 @@ dependencies:
   - bottleneck>=1.3.1
   - ipykernel
   - ipython>=7.11.1
-  - jinja2  # pandas.Styler
   - matplotlib>=3.3.2  # pandas.plotting, Series.plot, DataFrame.plot
   - numexpr>=2.7.1
   - scipy>=1.4.1
diff --git a/pandas/core/generic.py b/pandas/core/generic.py
index e171ded654989..f3387aa0ad9e7 100644
--- a/pandas/core/generic.py
+++ b/pandas/core/generic.py
@@ -26,7 +26,10 @@
 
 import numpy as np
 
-from pandas._config import config
+from pandas._config import (
+    config,
+    get_option,
+)
 
 from pandas._libs import lib
 from pandas._libs.tslibs import (
@@ -2108,7 +2111,7 @@ def _repr_latex_(self):
         Returns a LaTeX representation for a particular object.
         Mainly for use with nbconvert (jupyter notebook conversion to pdf).
         """
-        if config.get_option("display.latex.repr"):
+        if config.get_option("styler.render.repr") == "latex":
             return self.to_latex()
         else:
             return None
@@ -3116,32 +3119,45 @@ class      (index) object 'bird' 'bird' 'mammal' 'mammal'
     def to_latex(
         self,
         buf=None,
+        *,
+        hrules=False,
         columns=None,
-        col_space=None,
-        header=True,
-        index=True,
-        na_rep="NaN",
-        formatters=None,
-        float_format=None,
-        sparsify=None,
-        index_names=True,
-        bold_rows=False,
         column_format=None,
-        longtable=None,
+        position=None,
+        position_float=None,
+        caption=None,
+        label=None,
+        index=True,
+        header=True,
+        index_names="all",
+        sparse_index=None,
+        sparse_columns=None,
+        multirow_align=None,
+        multicol_align=None,
+        siunitx=False,
+        environment=None,
+        formatter=None,
+        precision=None,
+        na_rep=None,
+        decimal=None,
+        thousands=None,
         escape=None,
+        bold_header="none",
         encoding=None,
-        decimal=".",
+        formatters=None,
+        float_format=None,
         multicolumn=None,
         multicolumn_format=None,
         multirow=None,
-        caption=None,
-        label=None,
-        position=None,
+        longtable=None,
+        sparsify=None,
+        col_space=None,
+        bold_rows=None,
     ):
         r"""
         Render object to a LaTeX tabular, longtable, or nested table/tabular.
 
-        Requires ``\usepackage{{booktabs}}``.  The output can be copy/pasted
+        The output can be copy/pasted
         into a main LaTeX document or read from an external file
         with ``\input{{table.tex}}``.
 
@@ -3151,150 +3167,338 @@ def to_latex(
         .. versionchanged:: 1.2.0
            Added position argument, changed meaning of caption argument.
 
+        .. versionchanged:: 1.4.0
+           Now uses ``Styler.to_latex`` implementation via jinja2 templating.
+           Significant changes to arguments. See Notes.
+
         Parameters
         ----------
-        buf : str, Path or StringIO-like, optional, default None
-            Buffer to write to. If None, the output is returned as a string.
+        buf : str, Path or StringIO-like, optional
+            Buffer to write to. If `None`, the output is returned as a string.
+        hrules : bool
+            Set to `True` to add `\\toprule`, `\\midrule` and `\\bottomrule` from the
+            `booktabs` LaTeX package.
+
+            .. versionadded:: 1.4.0
         columns : list of label, optional
             The subset of columns to write. Writes all columns by default.
-        col_space : int, optional
-            The minimum width of each column.
-        header : bool or list of str, default True
-            Write out the column names. If a list of strings is given,
-            it is assumed to be aliases for the column names.
-        index : bool, default True
-            Write row names (index).
-        na_rep : str, default 'NaN'
-            Missing data representation.
-        formatters : list of functions or dict of {{str: function}}, optional
-            Formatter functions to apply to columns' elements by position or
-            name. The result of each function must be a unicode string.
-            List must be of length equal to the number of columns.
-        float_format : one-parameter function or str, optional, default None
-            Formatter for floating point numbers. For example
-            ``float_format="%.2f"`` and ``float_format="{{:0.2f}}".format`` will
-            both result in 0.1234 being formatted as 0.12.
-        sparsify : bool, optional
-            Set to False for a DataFrame with a hierarchical index to print
-            every multiindex key at each row. By default, the value will be
-            read from the config module.
-        index_names : bool, default True
-            Prints the names of the indexes.
-        bold_rows : bool, default False
-            Make the row labels bold in the output.
         column_format : str, optional
-            The columns format as specified in `LaTeX table format
-            <https://en.wikibooks.org/wiki/LaTeX/Tables>`__ e.g. 'rcl' for 3
-            columns. By default, 'l' will be used for all columns except
-            columns of numbers, which default to 'r'.
-        longtable : bool, optional
-            By default, the value will be read from the pandas config
-            module. Use a longtable environment instead of tabular. Requires
-            adding a \usepackage{{longtable}} to your LaTeX preamble.
-        escape : bool, optional
-            By default, the value will be read from the pandas config
-            module. When set to False prevents from escaping latex special
-            characters in column names.
+            The LaTeX column specification placed in location:
+
+            `\\begin{{tabular}}{{<column_format>}}`
+
+            Defaults to 'l' for index and
+            non-numeric data columns, and, for numeric data columns,
+            to 'r' by default, or 'S' if ``siunitx`` is `True`.
+
+            .. versionchanged:: 1.4.0
+        position : str, optional
+            The LaTeX positional argument (e.g. 'h!') for tables, placed in location:
+
+            `\\begin{{table}}[<position>]`.
+
+            .. versionchanged:: 1.2.0
+        position_float : {{"centering", "raggedleft", "raggedright"}}, optional
+            The LaTeX float command placed in location:
+
+            `\\begin{{table}}[<position>]`
+
+            `\\<position_float>`
+
+            Cannot be used if ``environment`` is "longtable".
+
+            .. versionadded:: 1.4.0
+        caption : str, tuple, optional
+            If string, then table caption included as: `\\caption{{<caption>}}`.
+            If tuple, i.e ("full caption", "short caption"), the caption included
+            as:
+
+            `\\caption[<caption[1]>]{{<caption[0]>}}`.
+
+            .. versionadded:: 1.0.0
+
+            .. versionchanged:: 1.2.0
+               Optionally allow caption to be a tuple `(full_caption, short_caption)`.
+        label : str, optional
+            The LaTeX label included as: `\\label{{<label>}}`.
+            This is used with `\\ref{{<label>}}` in the main .tex file.
+
+            .. versionadded:: 1.0.0
+        index : bool
+            Whether to print index labels.
+
+            .. versionchanged:: 1.4.0
+        header : bool or list of str
+            Whether to print column headers. If a list of strings is given is assumed
+            to be aliases for the column names.
+        index_names : {{"all", "index", "columns", "none"}}, bool
+            Whether to print the names of the indexes before rendering.
+
+            .. versionchanged:: 1.4.0
+        sparse_index : bool, optional
+            Whether to sparsify the display of a hierarchical index. Setting to False
+            will display each explicit level element in a hierarchical key for each row.
+            Defaults to ``pandas.options.styler.sparse.index``, which is `True`.
+
+            .. versionadded:: 1.4.0
+        sparse_columns : bool, optional
+            Equivalent to ``sparse_index`` applied to column headers.
+            Defaults to ``pandas.options.styler.sparse.columns``, which is `True`.
+
+            .. versionadded:: 1.4.0
+        multirow_align : {{"c", "t", "b", "naive"}}
+            If sparsifying hierarchical MultiIndexes, whether to align text centrally,
+            at the top or bottom. If "naive" is given will not use `multirow` package.
+            Defaults to ``pandas.options.styler.latex.multirow_align``, which is "c".
+
+            .. versionadded:: 1.4.0
+        multicol_align : {{"r", "c", "l", "naive-l", "naive-r"}}
+            If sparsifying hierarchical MultiIndex columns, whether to align text at
+            the left, centrally, or at the right. If a "naive" entry is given will not
+            use `multicolumn` package.
+            Defaults to ``pandas.options.styler.latex.multicol_align``, which is "r".
+
+            .. versionadded:: 1.4.0
+        siunitx : bool, default False
+            Set to `True` to structure LaTeX compatible with the `siunitx` package.
+
+            .. versionadded:: 1.4.0
+        environment : str, optional
+            If given, the environment that will replace "table" in `\\begin{{table}}`.
+            If "longtable" is specified then a more suitable template is
+            rendered.
+            Defaults to ``pandas.options.styler.latex.environment``, which is `None`.
+
+            .. versionadded:: 1.4.0
+        formatter : str, callable, dict, optional
+            Object to define how values are displayed. See notes for ``Styler.format``.
+            Defaults to ``pandas.options.styler.format.formatter``, which is `None`.
+
+            .. versionadded:: 1.4.0
+        precision : int, optional
+            Floating point precision to use for display purposes, if not determined by
+            the specified ``formatter``. Defaults to
+            ``pandas.options.styler.format.precision``, which is 6.
+
+            .. versionadded:: 1.4.0
+        na_rep : str, optional
+            Representation for missing values.
+            Defaults to ``pandas.options.styler.format.na_rep``, which is `None`.
+
+            .. versionchanged:: 1.4.0
+        decimal : str, default "."
+            Character used as decimal separator for floats, complex and integers.
+            Defaults to ``pandas.options.styler.format.decimal``, which is ".".
+        thousands : str, optional, default None
+            Character used as thousands separator for floats, complex and integers.
+            Defaults to ``pandas.options.styler.format.thousands``, which is `None`.
+
+            .. versionadded:: 1.4.0
+        escape : bool,
+            Replace the characters ``&``, ``%``, ``$``, ``#``, ``_``,
+            ``{{``, ``}}``, ``~``, ``^``, and ``\`` in the cell display string with
+            LaTeX-safe sequences.
+            Escaping is done before ``formatter``.
+            Defaults to (``pandas.options.styler.format.escape`` `=="latex"`), which
+            is `False`.
+
+            .. versionchanged:: 1.4.0
+        bold_header : {{"none", "index", "columns", "both"}}
+            Make the row labels and/or column headers bold in the output, using
+            command `\\textbf{{<value>}}`.
+
+            .. versionadded:: 1.4.0
         encoding : str, optional
-            A string representing the encoding to use in the output file,
-            defaults to 'utf-8'.
-        decimal : str, default '.'
-            Character recognized as decimal separator, e.g. ',' in Europe.
+            Character encoding setting for file output, defaults to
+            ``pandas.options.styler.render.encoding``, which is "utf-8", if None.
+
+            .. versionchanged:: 1.4.0
+        formatters : list, tuple or dict of one-param. functions, optional
+            Unused.
+
+            .. deprecated:: 1.4.0
+               Use ``formatter`` instead, which is passed to ``Styler.format``.
+        float_format : one-parameter function, optional, default None
+            Unused.
+
+            .. deprecated:: 1.4.0
+               Deprecated in favour of using arguments native to ``Styler.format``,
+               such as ``precision``, ``decimal``, and ``thousands``.
         multicolumn : bool, default True
-            Use \multicolumn to enhance MultiIndex columns.
-            The default will be read from the config module.
+            Unused.
+
+            .. deprecated:: 1.4.0
+              Use alternative ``sparse_columns`` and ``multicol_align`` arguments.
         multicolumn_format : str, default 'l'
-            The alignment for multicolumns, similar to `column_format`
-            The default will be read from the config module.
+            Unused.
+
+            .. deprecated:: 1.4.0
+              Use alternative ``sparse_columns`` and ``multicol_align`` arguments.
         multirow : bool, default False
-            Use \multirow to enhance MultiIndex rows. Requires adding a
-            \usepackage{{multirow}} to your LaTeX preamble. Will print
-            centered labels (instead of top-aligned) across the contained
-            rows, separating groups via clines. The default will be read
-            from the pandas config module.
-        caption : str or tuple, optional
-            Tuple (full_caption, short_caption),
-            which results in ``\caption[short_caption]{{full_caption}}``;
-            if a single string is passed, no short caption will be set.
+            Unused.
 
-            .. versionadded:: 1.0.0
+            .. deprecated:: 1.4.0
+              Use alternative ``sparse_index`` and ``multirow_align`` arguments.
+        longtable : bool
+            Unused.
 
-            .. versionchanged:: 1.2.0
-               Optionally allow caption to be a tuple ``(full_caption, short_caption)``.
+            .. deprecated:: 1.4.0
+               Use ``environment='longtable'`` instead.
+        sparsify : bool
+            Unused.
 
-        label : str, optional
-            The LaTeX label to be placed inside ``\label{{}}`` in the output.
-            This is used with ``\ref{{}}`` in the main ``.tex`` file.
+            .. deprecated:: 1.4.0
+               Use ``sparse_columns`` and ``sparse_rows`` instead.
+        col_space : int, optional
+            Unused.
 
-            .. versionadded:: 1.0.0
-        position : str, optional
-            The LaTeX positional argument for tables, to be placed after
-            ``\begin{{}}`` in the output.
+            .. deprecated:: 1.4.0
+               Adding LaTeX styling commands renders spacing not applicable.
+        bold_rows : bool, default False
+            Unused.
 
-            .. versionadded:: 1.2.0
+            .. deprecated:: 1.4.0
+               Use ``bold_header`` instead.
         {returns}
         See Also
         --------
+        Styler.to_latex : Render a Styler to LaTeX.
         DataFrame.to_string : Render a DataFrame to a console-friendly
             tabular output.
         DataFrame.to_html : Render a DataFrame as an HTML table.
 
+        Notes
+        -----
+
+        .. note::
+           As of version 1.4.0 this method was changed to use the implementation of
+           `Styler.to_latex()` via jinja2 templating, and no longer uses the pandas
+           internal `LatexFormatter` class. This is the reason for many of the
+           altered arguments in the method signature.
+
+           The Styler implementation has extended functionality and performance and
+           further information is available in its own documentation relevant for this
+           method.
+
         Examples
         --------
-        >>> df = pd.DataFrame(dict(name=['Raphael', 'Donatello'],
-        ...                   mask=['red', 'purple'],
-        ...                   weapon=['sai', 'bo staff']))
-        >>> print(df.to_latex(index=False))  # doctest: +NORMALIZE_WHITESPACE
+        >>> df = pd.DataFrame({{'name': ['Raphael', 'Donatello'],
+        ...                    'mask': ['red', 'purple'],
+        ...                    'weapon': ['sai', 'bo staff']}})
+        >>> print(df.to_latex(index=False, hrules=True))
         \begin{{tabular}}{{lll}}
-         \toprule
-               name &    mask &    weapon \\
-         \midrule
-            Raphael &     red &       sai \\
-          Donatello &  purple &  bo staff \\
+        \toprule
+        name & mask & weapon \\
+        \midrule
+        Raphael & red & sai \\
+        Donatello & purple & bo staff \\
         \bottomrule
         \end{{tabular}}
         """
-        # Get defaults from the pandas config
-        if self.ndim == 1:
-            self = self.to_frame()
-        if longtable is None:
-            longtable = config.get_option("display.latex.longtable")
-        if escape is None:
-            escape = config.get_option("display.latex.escape")
-        if multicolumn is None:
-            multicolumn = config.get_option("display.latex.multicolumn")
-        if multicolumn_format is None:
-            multicolumn_format = config.get_option("display.latex.multicolumn_format")
-        if multirow is None:
-            multirow = config.get_option("display.latex.multirow")
-
-        self = cast("DataFrame", self)
-        formatter = DataFrameFormatter(
-            self,
-            columns=columns,
-            col_space=col_space,
+        kwargs = locals()
+        deprecated_args = {
+            "longtable": '`environment="longtable"`',
+            "multicolumn": "`multicol_align`",
+            "multicolumn_format": "`multicol_align`",
+            "multirow": "`multirow_align`",
+            "col_space": None,
+            "formatters": "`formatter`, `precision`, `decimal`, `thousands`",
+            "float_format": "`precision`, `decimal`, `thousands`, `formatter`",
+            "sparsify": "`sparse_index`, `sparse_columns`",
+            "bold_rows": "`bold_header`",
+        }
+        for k, v in deprecated_args.items():
+            if kwargs[k] is not None:
+                warnings.warn(
+                    f"`{k}` is deprecated after transition to `Styler.to_latex()` "
+                    f"signature." + ("" if v is None else f" Consider {v} instead."),
+                    FutureWarning,
+                    stacklevel=2,
+                )
+
+        from pandas.io.formats.style import Styler
+
+        if (
+            escape is None and get_option("styler.format.escape") == "latex"
+        ) or escape is True:
+            escape = "latex"
+        else:
+            escape = None
+        # error: Argument 1 to "Styler" has incompatible type "NDFrame"; expected
+        # "Union[DataFrame, Series]"
+        styler = Styler(
+            self,  # type: ignore[arg-type]
+            uuid="",
+            formatter=formatter,
             na_rep=na_rep,
-            header=header,
-            index=index,
-            formatters=formatters,
-            float_format=float_format,
-            bold_rows=bold_rows,
-            sparsify=sparsify,
-            index_names=index_names,
-            escape=escape,
+            precision=precision,
             decimal=decimal,
+            thousands=thousands,
+            escape=escape,
         )
-        return DataFrameRenderer(formatter).to_latex(
+
+        for ax in [0, 1]:  #
+            fmt: Callable | str | None = None
+            if isinstance(formatter, dict):
+                fmt = formatter.get("__index__" if ax == 0 else "__columns__")
+            decimal = decimal or get_option("styler.format.decimal")
+            styler.format_index(
+                axis=ax,
+                escape="latex" if escape else None,
+                na_rep=na_rep,
+                decimal=decimal,
+                precision=precision,
+                thousands=thousands,
+                formatter=fmt,
+            )
+
+        if header is False:
+            styler.hide_columns()
+        elif isinstance(header, (list, tuple)):
+            if len(header) != len(styler.columns):
+                raise ValueError(
+                    f"`header` gave {len(header)} aliases for {len(styler.columns)} "
+                    f"columns."
+                )
+            for i, val in enumerate(header):
+
+                def disp(x, v):
+                    return f"{v}"
+
+                styler._display_funcs_columns[(0, i)] = functools.partial(disp, v=val)
+            if isinstance(styler.columns, MultiIndex):
+                styler.hide_columns(
+                    level=[i for i in range(styler.columns.nlevels) if i != 0]
+                )
+        if not index:
+            styler.hide_index()
+        if index_names is False or index_names in ["none", "columns"]:
+            styler.hide_index(names=True)
+        if index_names is False or index_names in ["none", "index"]:
+            styler.hide_columns(names=True)
+        if columns:
+            hidden = [col for col in styler.columns if col not in columns]
+            styler.hide_columns(hidden)
+        if bold_header in ["index", "both"]:
+            styler.applymap_index(lambda val: "textbf: --rwrap;")
+        if bold_header in ["columns", "both"]:
+            styler.applymap_index(lambda val: "textbf: --rwrap;", axis=1)
+
+        return styler.to_latex(
             buf=buf,
-            column_format=column_format,
-            longtable=longtable,
             encoding=encoding,
-            multicolumn=multicolumn,
-            multicolumn_format=multicolumn_format,
-            multirow=multirow,
-            caption=caption,
-            label=label,
+            sparse_index=sparse_index,
+            sparse_columns=sparse_columns,
+            column_format=column_format,
             position=position,
+            position_float=position_float,
+            hrules=hrules,
+            label=label,
+            caption=caption,
+            multirow_align=multirow_align,
+            multicol_align=multicol_align,
+            environment=environment,
+            siunitx=siunitx,
         )
 
     @final
diff --git a/pandas/io/formats/style.py b/pandas/io/formats/style.py
index 2fbd9506e391a..7653abf10244b 100644
--- a/pandas/io/formats/style.py
+++ b/pandas/io/formats/style.py
@@ -786,6 +786,8 @@ def to_latex(
         )
 
         if column_format is not None:
+            if not isinstance(column_format, str):
+                raise ValueError("`column_format` must be a string.")
             # add more recent setting to table_styles
             obj.set_table_styles(
                 [{"selector": "column_format", "props": f":{column_format}"}],
@@ -870,10 +872,12 @@ def to_latex(
             siunitx=siunitx,
         )
 
-        encoding = encoding or get_option("styler.render.encoding")
-        return save_to_buffer(
-            latex, buf=buf, encoding=None if buf is None else encoding
+        encoding = (
+            (encoding or get_option("styler.render.encoding"))
+            if isinstance(buf, str)  # i.e. a filepath
+            else encoding
         )
+        return save_to_buffer(latex, buf=buf, encoding=encoding)
 
     def to_html(
         self,
@@ -1800,7 +1804,7 @@ def set_caption(self, caption: str | tuple) -> Styler:
         self : Styler
         """
         msg = "`caption` must be either a string or 2-tuple of strings."
-        if isinstance(caption, tuple):
+        if isinstance(caption, (tuple, list)):
             if (
                 len(caption) != 2
                 or not isinstance(caption[0], str)
@@ -2218,9 +2222,7 @@ def hide_index(
             subset = non_reducing_slice(subset_)
             hide = self.data.loc[subset]
             hrows = self.index.get_indexer_for(hide.index)
-            # error: Incompatible types in assignment (expression has type
-            # "ndarray", variable has type "Sequence[int]")
-            self.hidden_rows = hrows  # type: ignore[assignment]
+            self.hidden_rows = list(hrows)
 
         if names:
             self.hide_index_names = True
@@ -2357,9 +2359,7 @@ def hide_columns(
             subset = non_reducing_slice(subset_)
             hide = self.data.loc[subset]
             hcols = self.columns.get_indexer_for(hide.columns)
-            # error: Incompatible types in assignment (expression has type
-            # "ndarray", variable has type "Sequence[int]")
-            self.hidden_columns = hcols  # type: ignore[assignment]
+            self.hidden_columns = list(hcols)
 
         if names:
             self.hide_column_names = True
diff --git a/pandas/tests/frame/test_repr_info.py b/pandas/tests/frame/test_repr_info.py
index e2cfc50510173..62393dd980c19 100644
--- a/pandas/tests/frame/test_repr_info.py
+++ b/pandas/tests/frame/test_repr_info.py
@@ -269,15 +269,12 @@ def test_repr_column_name_unicode_truncation_bug(self):
 
     def test_latex_repr(self):
         result = r"""\begin{tabular}{llll}
-\toprule
-{} &         0 &  1 &  2 \\
-\midrule
-0 &  $\alpha$ &  b &  c \\
-1 &         1 &  2 &  3 \\
-\bottomrule
+ & 0 & 1 & 2 \\
+0 & $\alpha$ & b & c \\
+1 & 1 & 2 & 3 \\
 \end{tabular}
 """
-        with option_context("display.latex.escape", False, "display.latex.repr", True):
+        with option_context("styler.render.repr", "latex"):
             df = DataFrame([[r"$\alpha$", "b", "c"], [1, 2, 3]])
             assert result == df._repr_latex_()
 
diff --git a/pandas/tests/io/formats/test_printing.py b/pandas/tests/io/formats/test_printing.py
index f0d5ef19c4468..9bc1840ed0aba 100644
--- a/pandas/tests/io/formats/test_printing.py
+++ b/pandas/tests/io/formats/test_printing.py
@@ -143,7 +143,7 @@ def test_publishes(self):
                 formatted = self.display_formatter.format(obj)
             assert set(formatted[0].keys()) == expected
 
-        with_latex = pd.option_context("display.latex.repr", True)
+        with_latex = pd.option_context("styler.render.repr", "latex")
 
         with opt, with_latex:
             formatted = self.display_formatter.format(obj)
diff --git a/pandas/tests/io/formats/test_to_latex.py b/pandas/tests/io/formats/test_to_latex.py
index 10c8ccae67fb2..8af398f1b565e 100644
--- a/pandas/tests/io/formats/test_to_latex.py
+++ b/pandas/tests/io/formats/test_to_latex.py
@@ -61,15 +61,15 @@ def test_to_latex_to_file_utf8_without_encoding(self):
 
     def test_to_latex_tabular_with_index(self):
         df = DataFrame({"a": [1, 2], "b": ["b1", "b2"]})
-        result = df.to_latex()
+        result = df.to_latex(hrules=True)
         expected = _dedent(
             r"""
             \begin{tabular}{lrl}
             \toprule
-            {} &  a &   b \\
+             & a & b \\
             \midrule
-            0 &  1 &  b1 \\
-            1 &  2 &  b2 \\
+            0 & 1 & b1 \\
+            1 & 2 & b2 \\
             \bottomrule
             \end{tabular}
             """
@@ -78,15 +78,15 @@ def test_to_latex_tabular_with_index(self):
 
     def test_to_latex_tabular_without_index(self):
         df = DataFrame({"a": [1, 2], "b": ["b1", "b2"]})
-        result = df.to_latex(index=False)
+        result = df.to_latex(index=False, hrules=True)
         expected = _dedent(
             r"""
             \begin{tabular}{rl}
             \toprule
-             a &  b \\
+            a & b \\
             \midrule
-             1 & b1 \\
-             2 & b2 \\
+            1 & b1 \\
+            2 & b2 \\
             \bottomrule
             \end{tabular}
             """
@@ -99,7 +99,7 @@ def test_to_latex_tabular_without_index(self):
     )
     def test_to_latex_bad_column_format(self, bad_column_format):
         df = DataFrame({"a": [1, 2], "b": ["b1", "b2"]})
-        msg = r"column_format must be str or unicode"
+        msg = r"`column_format` must be a string"
         with pytest.raises(ValueError, match=msg):
             df.to_latex(column_format=bad_column_format)
 
@@ -109,15 +109,15 @@ def test_to_latex_column_format_just_works(self, float_frame):
 
     def test_to_latex_column_format(self):
         df = DataFrame({"a": [1, 2], "b": ["b1", "b2"]})
-        result = df.to_latex(column_format="lcr")
+        result = df.to_latex(column_format="lcr", hrules=True)
         expected = _dedent(
             r"""
             \begin{tabular}{lcr}
             \toprule
-            {} &  a &   b \\
+             & a & b \\
             \midrule
-            0 &  1 &  b1 \\
-            1 &  2 &  b2 \\
+            0 & 1 & b1 \\
+            1 & 2 & b2 \\
             \bottomrule
             \end{tabular}
             """
@@ -127,15 +127,15 @@ def test_to_latex_column_format(self):
     def test_to_latex_float_format_object_col(self):
         # GH#40024
         ser = Series([1000.0, "test"])
-        result = ser.to_latex(float_format="{:,.0f}".format)
+        result = ser.to_latex(precision=0, thousands=",", hrules=True)
         expected = _dedent(
             r"""
             \begin{tabular}{ll}
             \toprule
-            {} &     0 \\
+             & 0 \\
             \midrule
             0 & 1,000 \\
-            1 &  test \\
+            1 & test \\
             \bottomrule
             \end{tabular}
             """
@@ -144,14 +144,12 @@ def test_to_latex_float_format_object_col(self):
 
     def test_to_latex_empty_tabular(self):
         df = DataFrame()
-        result = df.to_latex()
+        result = df.to_latex(hrules=True)
         expected = _dedent(
             r"""
             \begin{tabular}{l}
             \toprule
-            Empty DataFrame
-            Columns: Index([], dtype='object')
-            Index: Index([], dtype='object') \\
+            \midrule
             \bottomrule
             \end{tabular}
             """
@@ -160,16 +158,16 @@ def test_to_latex_empty_tabular(self):
 
     def test_to_latex_series(self):
         s = Series(["a", "b", "c"])
-        result = s.to_latex()
+        result = s.to_latex(hrules=True)
         expected = _dedent(
             r"""
             \begin{tabular}{ll}
             \toprule
-            {} &  0 \\
+             & 0 \\
             \midrule
-            0 &  a \\
-            1 &  b \\
-            2 &  c \\
+            0 & a \\
+            1 & b \\
+            2 & c \\
             \bottomrule
             \end{tabular}
             """
@@ -180,15 +178,15 @@ def test_to_latex_midrule_location(self):
         # GH 18326
         df = DataFrame({"a": [1, 2]})
         df.index.name = "foo"
-        result = df.to_latex(index_names=False)
+        result = df.to_latex(index_names=False, hrules=True)
         expected = _dedent(
             r"""
             \begin{tabular}{lr}
             \toprule
-            {} &  a \\
+             & a \\
             \midrule
-            0 &  1 \\
-            1 &  2 \\
+            0 & 1 \\
+            1 & 2 \\
             \bottomrule
             \end{tabular}
             """
@@ -199,14 +197,15 @@ def test_to_latex_midrule_location(self):
 class TestToLatexLongtable:
     def test_to_latex_empty_longtable(self):
         df = DataFrame()
-        result = df.to_latex(longtable=True)
+        result = df.to_latex(environment="longtable")
         expected = _dedent(
             r"""
             \begin{longtable}{l}
-            \toprule
-            Empty DataFrame
-            Columns: Index([], dtype='object')
-            Index: Index([], dtype='object') \\
+            \endfirsthead
+            \endhead
+            \multicolumn{1}{r}{Continued on next page} \\
+            \endfoot
+            \endlastfoot
             \end{longtable}
             """
         )
@@ -214,28 +213,26 @@ def test_to_latex_empty_longtable(self):
 
     def test_to_latex_longtable_with_index(self):
         df = DataFrame({"a": [1, 2], "b": ["b1", "b2"]})
-        result = df.to_latex(longtable=True)
+        result = df.to_latex(environment="longtable", hrules=True)
         expected = _dedent(
             r"""
             \begin{longtable}{lrl}
             \toprule
-            {} &  a &   b \\
+             & a & b \\
             \midrule
             \endfirsthead
-
             \toprule
-            {} &  a &   b \\
+             & a & b \\
             \midrule
             \endhead
             \midrule
-            \multicolumn{3}{r}{{Continued on next page}} \\
+            \multicolumn{3}{r}{Continued on next page} \\
             \midrule
             \endfoot
-
             \bottomrule
             \endlastfoot
-            0 &  1 &  b1 \\
-            1 &  2 &  b2 \\
+            0 & 1 & b1 \\
+            1 & 2 & b2 \\
             \end{longtable}
             """
         )
@@ -243,28 +240,26 @@ def test_to_latex_longtable_with_index(self):
 
     def test_to_latex_longtable_without_index(self):
         df = DataFrame({"a": [1, 2], "b": ["b1", "b2"]})
-        result = df.to_latex(index=False, longtable=True)
+        result = df.to_latex(index=False, environment="longtable", hrules=True)
         expected = _dedent(
             r"""
             \begin{longtable}{rl}
             \toprule
-             a &  b \\
+            a & b \\
             \midrule
             \endfirsthead
-
             \toprule
-             a &  b \\
+            a & b \\
             \midrule
             \endhead
             \midrule
-            \multicolumn{2}{r}{{Continued on next page}} \\
+            \multicolumn{2}{r}{Continued on next page} \\
             \midrule
             \endfoot
-
             \bottomrule
             \endlastfoot
-             1 & b1 \\
-             2 & b2 \\
+            1 & b1 \\
+            2 & b2 \\
             \end{longtable}
             """
         )
@@ -279,7 +274,7 @@ def test_to_latex_longtable_without_index(self):
         ],
     )
     def test_to_latex_longtable_continued_on_next_page(self, df, expected_number):
-        result = df.to_latex(index=False, longtable=True)
+        result = df.to_latex(index=False, environment="longtable")
         assert fr"\multicolumn{{{expected_number}}}" in result
 
 
@@ -287,13 +282,14 @@ class TestToLatexHeader:
     def test_to_latex_no_header_with_index(self):
         # GH 7124
         df = DataFrame({"a": [1, 2], "b": ["b1", "b2"]})
-        result = df.to_latex(header=False)
+        result = df.to_latex(header=False, hrules=True)
         expected = _dedent(
             r"""
             \begin{tabular}{lrl}
             \toprule
-            0 &  1 &  b1 \\
-            1 &  2 &  b2 \\
+            \midrule
+            0 & 1 & b1 \\
+            1 & 2 & b2 \\
             \bottomrule
             \end{tabular}
             """
@@ -303,11 +299,12 @@ def test_to_latex_no_header_with_index(self):
     def test_to_latex_no_header_without_index(self):
         # GH 7124
         df = DataFrame({"a": [1, 2], "b": ["b1", "b2"]})
-        result = df.to_latex(index=False, header=False)
+        result = df.to_latex(index=False, header=False, hrules=True)
         expected = _dedent(
             r"""
             \begin{tabular}{rl}
             \toprule
+            \midrule
             1 & b1 \\
             2 & b2 \\
             \bottomrule
@@ -319,15 +316,15 @@ def test_to_latex_no_header_without_index(self):
     def test_to_latex_specified_header_with_index(self):
         # GH 7124
         df = DataFrame({"a": [1, 2], "b": ["b1", "b2"]})
-        result = df.to_latex(header=["AA", "BB"])
+        result = df.to_latex(header=["AA", "BB"], hrules=True)
         expected = _dedent(
             r"""
             \begin{tabular}{lrl}
             \toprule
-            {} & AA &  BB \\
+             & AA & BB \\
             \midrule
-            0 &  1 &  b1 \\
-            1 &  2 &  b2 \\
+            0 & 1 & b1 \\
+            1 & 2 & b2 \\
             \bottomrule
             \end{tabular}
             """
@@ -337,15 +334,15 @@ def test_to_latex_specified_header_with_index(self):
     def test_to_latex_specified_header_without_index(self):
         # GH 7124
         df = DataFrame({"a": [1, 2], "b": ["b1", "b2"]})
-        result = df.to_latex(header=["AA", "BB"], index=False)
+        result = df.to_latex(header=["AA", "BB"], index=False, hrules=True)
         expected = _dedent(
             r"""
             \begin{tabular}{rl}
             \toprule
             AA & BB \\
             \midrule
-             1 & b1 \\
-             2 & b2 \\
+            1 & b1 \\
+            2 & b2 \\
             \bottomrule
             \end{tabular}
             """
@@ -368,22 +365,22 @@ def test_to_latex_number_of_items_in_header_missmatch_raises(
     ):
         # GH 7124
         df = DataFrame({"a": [1, 2], "b": ["b1", "b2"]})
-        msg = f"Writing 2 cols but got {num_aliases} aliases"
+        msg = f"`header` gave {num_aliases} aliases for 2 columns."
         with pytest.raises(ValueError, match=msg):
             df.to_latex(header=header)
 
     def test_to_latex_decimal(self):
         # GH 12031
         df = DataFrame({"a": [1.0, 2.1], "b": ["b1", "b2"]})
-        result = df.to_latex(decimal=",")
+        result = df.to_latex(decimal=",", precision=1, hrules=True)
         expected = _dedent(
             r"""
             \begin{tabular}{lrl}
             \toprule
-            {} &    a &   b \\
+             & a & b \\
             \midrule
-            0 &  1,0 &  b1 \\
-            1 &  2,1 &  b2 \\
+            0 & 1,0 & b1 \\
+            1 & 2,1 & b2 \\
             \bottomrule
             \end{tabular}
             """
@@ -392,38 +389,28 @@ def test_to_latex_decimal(self):
 
 
 class TestToLatexBold:
-    def test_to_latex_bold_rows(self):
+    @pytest.mark.parametrize("bold_header", ["both", "none", "index", "columns"])
+    def test_to_latex_bold_rows(self, bold_header):
         # GH 16707
-        df = DataFrame({"a": [1, 2], "b": ["b1", "b2"]})
-        result = df.to_latex(bold_rows=True)
-        expected = _dedent(
-            r"""
-            \begin{tabular}{lrl}
-            \toprule
-            {} &  a &   b \\
-            \midrule
-            \textbf{0} &  1 &  b1 \\
-            \textbf{1} &  2 &  b2 \\
-            \bottomrule
-            \end{tabular}
-            """
+        cols = (
+            "\\textbf{a} & \\textbf{b}"
+            if bold_header in ["both", "columns"]
+            else "a & b"
         )
-        assert result == expected
-
-    def test_to_latex_no_bold_rows(self):
-        # GH 16707
+        idx1 = "\\textbf{0}" if bold_header in ["both", "index"] else "0"
+        idx2 = "\\textbf{1}" if bold_header in ["both", "index"] else "1"
         df = DataFrame({"a": [1, 2], "b": ["b1", "b2"]})
-        result = df.to_latex(bold_rows=False)
+        result = df.to_latex(bold_header=bold_header, hrules=True)
         expected = _dedent(
-            r"""
-            \begin{tabular}{lrl}
-            \toprule
-            {} &  a &   b \\
-            \midrule
-            0 &  1 &  b1 \\
-            1 &  2 &  b2 \\
-            \bottomrule
-            \end{tabular}
+            f"""
+            \\begin{{tabular}}{{lrl}}
+            \\toprule
+             & {cols} \\\\
+            \\midrule
+            {idx1} & 1 & b1 \\\\
+            {idx2} & 2 & b2 \\\\
+            \\bottomrule
+            \\end{{tabular}}
             """
         )
         assert result == expected
@@ -457,7 +444,9 @@ def label_longtable(self):
 
     def test_to_latex_caption_only(self, df_short, caption_table):
         # GH 25436
-        result = df_short.to_latex(caption=caption_table)
+        result = df_short.to_latex(
+            caption=caption_table, hrules=True, position_float="centering"
+        )
         expected = _dedent(
             r"""
             \begin{table}
@@ -465,10 +454,10 @@ def test_to_latex_caption_only(self, df_short, caption_table):
             \caption{a table in a \texttt{table/tabular} environment}
             \begin{tabular}{lrl}
             \toprule
-            {} &  a &   b \\
+             & a & b \\
             \midrule
-            0 &  1 &  b1 \\
-            1 &  2 &  b2 \\
+            0 & 1 & b1 \\
+            1 & 2 & b2 \\
             \bottomrule
             \end{tabular}
             \end{table}
@@ -478,7 +467,9 @@ def test_to_latex_caption_only(self, df_short, caption_table):
 
     def test_to_latex_label_only(self, df_short, label_table):
         # GH 25436
-        result = df_short.to_latex(label=label_table)
+        result = df_short.to_latex(
+            label=label_table, position_float="centering", hrules=True
+        )
         expected = _dedent(
             r"""
             \begin{table}
@@ -486,10 +477,10 @@ def test_to_latex_label_only(self, df_short, label_table):
             \label{tab:table_tabular}
             \begin{tabular}{lrl}
             \toprule
-            {} &  a &   b \\
+             & a & b \\
             \midrule
-            0 &  1 &  b1 \\
-            1 &  2 &  b2 \\
+            0 & 1 & b1 \\
+            1 & 2 & b2 \\
             \bottomrule
             \end{tabular}
             \end{table}
@@ -499,7 +490,12 @@ def test_to_latex_label_only(self, df_short, label_table):
 
     def test_to_latex_caption_and_label(self, df_short, caption_table, label_table):
         # GH 25436
-        result = df_short.to_latex(caption=caption_table, label=label_table)
+        result = df_short.to_latex(
+            caption=caption_table,
+            label=label_table,
+            hrules=True,
+            position_float="centering",
+        )
         expected = _dedent(
             r"""
             \begin{table}
@@ -508,10 +504,10 @@ def test_to_latex_caption_and_label(self, df_short, caption_table, label_table):
             \label{tab:table_tabular}
             \begin{tabular}{lrl}
             \toprule
-            {} &  a &   b \\
+             & a & b \\
             \midrule
-            0 &  1 &  b1 \\
-            1 &  2 &  b2 \\
+            0 & 1 & b1 \\
+            1 & 2 & b2 \\
             \bottomrule
             \end{tabular}
             \end{table}
@@ -525,7 +521,11 @@ def test_to_latex_caption_and_shortcaption(
         caption_table,
         short_caption,
     ):
-        result = df_short.to_latex(caption=(caption_table, short_caption))
+        result = df_short.to_latex(
+            caption=(caption_table, short_caption),
+            hrules=True,
+            position_float="centering",
+        )
         expected = _dedent(
             r"""
             \begin{table}
@@ -533,10 +533,10 @@ def test_to_latex_caption_and_shortcaption(
             \caption[a table]{a table in a \texttt{table/tabular} environment}
             \begin{tabular}{lrl}
             \toprule
-            {} &  a &   b \\
+             & a & b \\
             \midrule
-            0 &  1 &  b1 \\
-            1 &  2 &  b2 \\
+            0 & 1 & b1 \\
+            1 & 2 & b2 \\
             \bottomrule
             \end{tabular}
             \end{table}
@@ -561,6 +561,8 @@ def test_to_latex_caption_shortcaption_and_label(
         result = df_short.to_latex(
             caption=(caption_table, short_caption),
             label=label_table,
+            hrules=True,
+            position_float="centering",
         )
         expected = _dedent(
             r"""
@@ -570,10 +572,10 @@ def test_to_latex_caption_shortcaption_and_label(
             \label{tab:table_tabular}
             \begin{tabular}{lrl}
             \toprule
-            {} &  a &   b \\
+             & a & b \\
             \midrule
-            0 &  1 &  b1 \\
-            1 &  2 &  b2 \\
+            0 & 1 & b1 \\
+            1 & 2 & b2 \\
             \bottomrule
             \end{tabular}
             \end{table}
@@ -594,14 +596,16 @@ def test_to_latex_caption_shortcaption_and_label(
     def test_to_latex_bad_caption_raises(self, bad_caption):
         # test that wrong number of params is raised
         df = DataFrame({"a": [1]})
-        msg = "caption must be either a string or a tuple of two strings"
+        msg = "`caption` must be either a string or 2-tuple of strings."
         with pytest.raises(ValueError, match=msg):
             df.to_latex(caption=bad_caption)
 
     def test_to_latex_two_chars_caption(self, df_short):
         # test that two chars caption is handled correctly
         # it must not be unpacked into long_caption, short_caption.
-        result = df_short.to_latex(caption="xy")
+        result = df_short.to_latex(
+            caption="xy", hrules=True, position_float="centering"
+        )
         expected = _dedent(
             r"""
             \begin{table}
@@ -609,10 +613,10 @@ def test_to_latex_two_chars_caption(self, df_short):
             \caption{xy}
             \begin{tabular}{lrl}
             \toprule
-            {} &  a &   b \\
+             & a & b \\
             \midrule
-            0 &  1 &  b1 \\
-            1 &  2 &  b2 \\
+            0 & 1 & b1 \\
+            1 & 2 & b2 \\
             \bottomrule
             \end{tabular}
             \end{table}
@@ -624,29 +628,30 @@ def test_to_latex_longtable_caption_only(self, df_short, caption_longtable):
         # GH 25436
         # test when no caption and no label is provided
         # is performed by test_to_latex_longtable()
-        result = df_short.to_latex(longtable=True, caption=caption_longtable)
+        result = df_short.to_latex(
+            environment="longtable", caption=caption_longtable, hrules=True
+        )
         expected = _dedent(
             r"""
             \begin{longtable}{lrl}
-            \caption{a table in a \texttt{longtable} environment}\\
+            \caption{a table in a \texttt{longtable} environment} \\
             \toprule
-            {} &  a &   b \\
+             & a & b \\
             \midrule
             \endfirsthead
             \caption[]{a table in a \texttt{longtable} environment} \\
             \toprule
-            {} &  a &   b \\
+             & a & b \\
             \midrule
             \endhead
             \midrule
-            \multicolumn{3}{r}{{Continued on next page}} \\
+            \multicolumn{3}{r}{Continued on next page} \\
             \midrule
             \endfoot
-
             \bottomrule
             \endlastfoot
-            0 &  1 &  b1 \\
-            1 &  2 &  b2 \\
+            0 & 1 & b1 \\
+            1 & 2 & b2 \\
             \end{longtable}
             """
         )
@@ -654,29 +659,29 @@ def test_to_latex_longtable_caption_only(self, df_short, caption_longtable):
 
     def test_to_latex_longtable_label_only(self, df_short, label_longtable):
         # GH 25436
-        result = df_short.to_latex(longtable=True, label=label_longtable)
+        result = df_short.to_latex(
+            environment="longtable", label=label_longtable, hrules=True
+        )
         expected = _dedent(
             r"""
             \begin{longtable}{lrl}
-            \label{tab:longtable}\\
+            \label{tab:longtable} \\
             \toprule
-            {} &  a &   b \\
+             & a & b \\
             \midrule
             \endfirsthead
-
             \toprule
-            {} &  a &   b \\
+             & a & b \\
             \midrule
             \endhead
             \midrule
-            \multicolumn{3}{r}{{Continued on next page}} \\
+            \multicolumn{3}{r}{Continued on next page} \\
             \midrule
             \endfoot
-
             \bottomrule
             \endlastfoot
-            0 &  1 &  b1 \\
-            1 &  2 &  b2 \\
+            0 & 1 & b1 \\
+            1 & 2 & b2 \\
             \end{longtable}
             """
         )
@@ -690,35 +695,34 @@ def test_to_latex_longtable_caption_and_label(
     ):
         # GH 25436
         result = df_short.to_latex(
-            longtable=True,
+            environment="longtable",
+            hrules=True,
             caption=caption_longtable,
             label=label_longtable,
         )
         expected = _dedent(
             r"""
-            \begin{longtable}{lrl}
-            \caption{a table in a \texttt{longtable} environment}
-            \label{tab:longtable}\\
-            \toprule
-            {} &  a &   b \\
-            \midrule
-            \endfirsthead
-            \caption[]{a table in a \texttt{longtable} environment} \\
-            \toprule
-            {} &  a &   b \\
-            \midrule
-            \endhead
-            \midrule
-            \multicolumn{3}{r}{{Continued on next page}} \\
-            \midrule
-            \endfoot
-
-            \bottomrule
-            \endlastfoot
-            0 &  1 &  b1 \\
-            1 &  2 &  b2 \\
-            \end{longtable}
-            """
+        \begin{longtable}{lrl}
+        \caption{a table in a \texttt{longtable} environment} \label{tab:longtable} \\
+        \toprule
+         & a & b \\
+        \midrule
+        \endfirsthead
+        \caption[]{a table in a \texttt{longtable} environment} \\
+        \toprule
+         & a & b \\
+        \midrule
+        \endhead
+        \midrule
+        \multicolumn{3}{r}{Continued on next page} \\
+        \midrule
+        \endfoot
+        \bottomrule
+        \endlastfoot
+        0 & 1 & b1 \\
+        1 & 2 & b2 \\
+        \end{longtable}
+        """
         )
         assert result == expected
 
@@ -731,35 +735,34 @@ def test_to_latex_longtable_caption_shortcaption_and_label(
     ):
         # test when the caption, the short_caption and the label are provided
         result = df_short.to_latex(
-            longtable=True,
+            environment="longtable",
             caption=(caption_longtable, short_caption),
             label=label_longtable,
+            hrules=True,
         )
         expected = _dedent(
             r"""
-            \begin{longtable}{lrl}
-            \caption[a table]{a table in a \texttt{longtable} environment}
-            \label{tab:longtable}\\
-            \toprule
-            {} &  a &   b \\
-            \midrule
-            \endfirsthead
-            \caption[]{a table in a \texttt{longtable} environment} \\
-            \toprule
-            {} &  a &   b \\
-            \midrule
-            \endhead
-            \midrule
-            \multicolumn{3}{r}{{Continued on next page}} \\
-            \midrule
-            \endfoot
-
-            \bottomrule
-            \endlastfoot
-            0 &  1 &  b1 \\
-            1 &  2 &  b2 \\
-            \end{longtable}
-            """
+\begin{longtable}{lrl}
+\caption[a table]{a table in a \texttt{longtable} environment} \label{tab:longtable} \\
+\toprule
+ & a & b \\
+\midrule
+\endfirsthead
+\caption[]{a table in a \texttt{longtable} environment} \\
+\toprule
+ & a & b \\
+\midrule
+\endhead
+\midrule
+\multicolumn{3}{r}{Continued on next page} \\
+\midrule
+\endfoot
+\bottomrule
+\endlastfoot
+0 & 1 & b1 \\
+1 & 2 & b2 \\
+\end{longtable}
+"""
         )
         assert result == expected
 
@@ -773,31 +776,32 @@ def df_with_symbols(self):
         yield DataFrame({"co$e^x$": {a: "a", b: "b"}, "co^l1": {a: "a", b: "b"}})
 
     def test_to_latex_escape_false(self, df_with_symbols):
-        result = df_with_symbols.to_latex(escape=False)
+        result = df_with_symbols.to_latex(hrules=True)
         expected = _dedent(
             r"""
             \begin{tabular}{lll}
             \toprule
-            {} & co$e^x$ & co^l1 \\
+             & co$e^x$ & co^l1 \\
             \midrule
-            a &       a &     a \\
-            b &       b &     b \\
+            a & a & a \\
+            b & b & b \\
             \bottomrule
             \end{tabular}
             """
         )
         assert result == expected
 
-    def test_to_latex_escape_default(self, df_with_symbols):
-        result = df_with_symbols.to_latex()  # default: escape=True
+    def test_to_latex_escape_true(self, df_with_symbols):
+        # note default changed with 1.4.0
+        result = df_with_symbols.to_latex(hrules=True, escape=True)
         expected = _dedent(
             r"""
             \begin{tabular}{lll}
             \toprule
-            {} & co\$e\textasciicircum x\$ & co\textasciicircum l1 \\
+             & co\$e\textasciicircum x\$ & co\textasciicircum l1 \\
             \midrule
-            a &       a &     a \\
-            b &       b &     b \\
+            a & a & a \\
+            b & b & b \\
             \bottomrule
             \end{tabular}
             """
@@ -806,16 +810,16 @@ def test_to_latex_escape_default(self, df_with_symbols):
 
     def test_to_latex_special_escape(self):
         df = DataFrame([r"a\b\c", r"^a^b^c", r"~a~b~c"])
-        result = df.to_latex()
+        result = df.to_latex(hrules=True, escape=True)
         expected = _dedent(
             r"""
             \begin{tabular}{ll}
             \toprule
-            {} &       0 \\
+             & 0 \\
             \midrule
-            0 &   a\textbackslash b\textbackslash c \\
-            1 &  \textasciicircum a\textasciicircum b\textasciicircum c \\
-            2 &  \textasciitilde a\textasciitilde b\textasciitilde c \\
+            0 & a\textbackslash b\textbackslash c \\
+            1 & \textasciicircum a\textasciicircum b\textasciicircum c \\
+            2 & \textasciitilde a\textasciitilde b\textasciitilde c \\
             \bottomrule
             \end{tabular}
             """
@@ -825,23 +829,23 @@ def test_to_latex_special_escape(self):
     def test_to_latex_escape_special_chars(self):
         special_characters = ["&", "%", "$", "#", "_", "{", "}", "~", "^", "\\"]
         df = DataFrame(data=special_characters)
-        result = df.to_latex()
+        result = df.to_latex(hrules=True, escape=True)
         expected = _dedent(
             r"""
             \begin{tabular}{ll}
             \toprule
-            {} &  0 \\
-            \midrule
-            0 &  \& \\
-            1 &  \% \\
-            2 &  \$ \\
-            3 &  \# \\
-            4 &  \_ \\
-            5 &  \{ \\
-            6 &  \} \\
-            7 &  \textasciitilde  \\
-            8 &  \textasciicircum  \\
-            9 &  \textbackslash  \\
+             & 0 \\
+            \midrule
+            0 & \& \\
+            1 & \% \\
+            2 & \$ \\
+            3 & \# \\
+            4 & \_ \\
+            5 & \{ \\
+            6 & \} \\
+            7 & \textasciitilde  \\
+            8 & \textasciicircum  \\
+            9 & \textbackslash  \\
             \bottomrule
             \end{tabular}
             """
@@ -851,15 +855,15 @@ def test_to_latex_escape_special_chars(self):
     def test_to_latex_specified_header_special_chars_without_escape(self):
         # GH 7124
         df = DataFrame({"a": [1, 2], "b": ["b1", "b2"]})
-        result = df.to_latex(header=["$A$", "$B$"], escape=False)
+        result = df.to_latex(header=["$A$", "$B$"], escape=False, hrules=True)
         expected = _dedent(
             r"""
             \begin{tabular}{lrl}
             \toprule
-            {} & $A$ & $B$ \\
+             & $A$ & $B$ \\
             \midrule
-            0 &   1 &  b1 \\
-            1 &   2 &  b2 \\
+            0 & 1 & b1 \\
+            1 & 2 & b2 \\
             \bottomrule
             \end{tabular}
             """
@@ -871,17 +875,19 @@ class TestToLatexPosition:
     def test_to_latex_position(self):
         the_position = "h"
         df = DataFrame({"a": [1, 2], "b": ["b1", "b2"]})
-        result = df.to_latex(position=the_position)
+        result = df.to_latex(
+            position=the_position, position_float="centering", hrules=True
+        )
         expected = _dedent(
             r"""
             \begin{table}[h]
             \centering
             \begin{tabular}{lrl}
             \toprule
-            {} &  a &   b \\
+             & a & b \\
             \midrule
-            0 &  1 &  b1 \\
-            1 &  2 &  b2 \\
+            0 & 1 & b1 \\
+            1 & 2 & b2 \\
             \bottomrule
             \end{tabular}
             \end{table}
@@ -890,30 +896,27 @@ def test_to_latex_position(self):
         assert result == expected
 
     def test_to_latex_longtable_position(self):
-        the_position = "t"
         df = DataFrame({"a": [1, 2], "b": ["b1", "b2"]})
-        result = df.to_latex(longtable=True, position=the_position)
+        result = df.to_latex(environment="longtable", position="t", hrules=True)
         expected = _dedent(
             r"""
             \begin{longtable}[t]{lrl}
             \toprule
-            {} &  a &   b \\
+             & a & b \\
             \midrule
             \endfirsthead
-
             \toprule
-            {} &  a &   b \\
+             & a & b \\
             \midrule
             \endhead
             \midrule
-            \multicolumn{3}{r}{{Continued on next page}} \\
+            \multicolumn{3}{r}{Continued on next page} \\
             \midrule
             \endfoot
-
             \bottomrule
             \endlastfoot
-            0 &  1 &  b1 \\
-            1 &  2 &  b2 \\
+            0 & 1 & b1 \\
+            1 & 2 & b2 \\
             \end{longtable}
             """
         )
@@ -942,17 +945,17 @@ def test_to_latex_with_formatters(self):
             "object": lambda x: f"-{x!s}-",
             "__index__": lambda x: f"index: {x}",
         }
-        result = df.to_latex(formatters=dict(formatters))
+        result = df.to_latex(formatter=formatters, hrules=True)
 
         expected = _dedent(
             r"""
             \begin{tabular}{llrrl}
             \toprule
-            {} & datetime64 &  float & int &    object \\
+             & datetime64 & float & int & object \\
             \midrule
-            index: 0 &    2016-01 & [ 1.0] & 0x1 &  -(1, 2)- \\
-            index: 1 &    2016-02 & [ 2.0] & 0x2 &    -True- \\
-            index: 2 &    2016-03 & [ 3.0] & 0x3 &   -False- \\
+            index: 0 & 2016-01 & [ 1.0] & 0x1 & -(1, 2)- \\
+            index: 1 & 2016-02 & [ 2.0] & 0x2 & -True- \\
+            index: 2 & 2016-03 & [ 3.0] & 0x3 & -False- \\
             \bottomrule
             \end{tabular}
             """
@@ -962,12 +965,12 @@ def test_to_latex_with_formatters(self):
     def test_to_latex_float_format_no_fixed_width_3decimals(self):
         # GH 21625
         df = DataFrame({"x": [0.19999]})
-        result = df.to_latex(float_format="%.3f")
+        result = df.to_latex(formatter="{:.3f}", hrules=True)
         expected = _dedent(
             r"""
             \begin{tabular}{lr}
             \toprule
-            {} &     x \\
+             & x \\
             \midrule
             0 & 0.200 \\
             \bottomrule
@@ -979,12 +982,12 @@ def test_to_latex_float_format_no_fixed_width_3decimals(self):
     def test_to_latex_float_format_no_fixed_width_integer(self):
         # GH 22270
         df = DataFrame({"x": [100.0]})
-        result = df.to_latex(float_format="%.0f")
+        result = df.to_latex(formatter="{:.0f}", hrules=True)
         expected = _dedent(
             r"""
             \begin{tabular}{lr}
             \toprule
-            {} &   x \\
+             & x \\
             \midrule
             0 & 100 \\
             \bottomrule
@@ -1002,15 +1005,15 @@ def test_to_latex_na_rep_and_float_format(self, na_rep):
             ],
             columns=["Group", "Data"],
         )
-        result = df.to_latex(na_rep=na_rep, float_format="{:.2f}".format)
+        result = df.to_latex(na_rep=na_rep, precision=2, hrules=True)
         expected = _dedent(
             fr"""
             \begin{{tabular}}{{llr}}
             \toprule
-            {{}} & Group &  Data \\
+             & Group & Data \\
             \midrule
-            0 &     A &  1.22 \\
-            1 &     A &   {na_rep} \\
+            0 & A & 1.22 \\
+            1 & A & {na_rep} \\
             \bottomrule
             \end{{tabular}}
             """
@@ -1049,15 +1052,15 @@ def test_to_latex_multindex_header(self):
         # GH 16718
         df = DataFrame({"a": [0], "b": [1], "c": [2], "d": [3]})
         df = df.set_index(["a", "b"])
-        observed = df.to_latex(header=["r1", "r2"])
+        observed = df.to_latex(header=["r1", "r2"], hrules=True)
         expected = _dedent(
             r"""
             \begin{tabular}{llrr}
             \toprule
-              &   & r1 & r2 \\
-            a & b &    &    \\
+             &  & r1 & r2 \\
+            a & b &  &  \\
             \midrule
-            0 & 1 &  2 &  3 \\
+            0 & 1 & 2 & 3 \\
             \bottomrule
             \end{tabular}
             """
@@ -1068,13 +1071,13 @@ def test_to_latex_multiindex_empty_name(self):
         # GH 18669
         mi = pd.MultiIndex.from_product([[1, 2]], names=[""])
         df = DataFrame(-1, index=mi, columns=range(4))
-        observed = df.to_latex()
+        observed = df.to_latex(hrules=True)
         expected = _dedent(
             r"""
             \begin{tabular}{lrrrr}
             \toprule
-              &  0 &  1 &  2 &  3 \\
-            {} &    &    &    &    \\
+             & 0 & 1 & 2 & 3 \\
+             &  &  &  &  \\
             \midrule
             1 & -1 & -1 & -1 & -1 \\
             2 & -1 & -1 & -1 & -1 \\
@@ -1086,15 +1089,15 @@ def test_to_latex_multiindex_empty_name(self):
 
     def test_to_latex_multiindex_column_tabular(self):
         df = DataFrame({("x", "y"): ["a"]})
-        result = df.to_latex()
+        result = df.to_latex(hrules=True)
         expected = _dedent(
             r"""
             \begin{tabular}{ll}
             \toprule
-            {} &  x \\
-            {} &  y \\
+             & x \\
+             & y \\
             \midrule
-            0 &  a \\
+            0 & a \\
             \bottomrule
             \end{tabular}
             """
@@ -1103,14 +1106,14 @@ def test_to_latex_multiindex_column_tabular(self):
 
     def test_to_latex_multiindex_small_tabular(self):
         df = DataFrame({("x", "y"): ["a"]}).T
-        result = df.to_latex()
+        result = df.to_latex(hrules=True)
         expected = _dedent(
             r"""
             \begin{tabular}{lll}
             \toprule
-              &   &  0 \\
+             &  & 0 \\
             \midrule
-            x & y &  a \\
+            x & y & a \\
             \bottomrule
             \end{tabular}
             """
@@ -1118,18 +1121,18 @@ def test_to_latex_multiindex_small_tabular(self):
         assert result == expected
 
     def test_to_latex_multiindex_tabular(self, multiindex_frame):
-        result = multiindex_frame.to_latex()
+        result = multiindex_frame.to_latex(hrules=True, multirow_align="naive")
         expected = _dedent(
             r"""
             \begin{tabular}{llrrrr}
             \toprule
-               &   &  0 &  1 &  2 &  3 \\
+             &  & 0 & 1 & 2 & 3 \\
             \midrule
-            c1 & 0 &  0 &  1 &  2 &  3 \\
-               & 1 &  4 &  5 &  6 &  7 \\
-            c2 & 0 &  0 &  1 &  2 &  3 \\
-               & 1 &  4 &  5 &  6 &  7 \\
-            c3 & 0 &  0 &  1 &  2 &  3 \\
+            c1 & 0 & 0 & 1 & 2 & 3 \\
+             & 1 & 4 & 5 & 6 & 7 \\
+            c2 & 0 & 0 & 1 & 2 & 3 \\
+             & 1 & 4 & 5 & 6 & 7 \\
+            c3 & 0 & 0 & 1 & 2 & 3 \\
             \bottomrule
             \end{tabular}
             """
@@ -1140,18 +1143,18 @@ def test_to_latex_multicolumn_tabular(self, multiindex_frame):
         # GH 14184
         df = multiindex_frame.T
         df.columns.names = ["a", "b"]
-        result = df.to_latex()
+        result = df.to_latex(hrules=True, multicol_align="l")
         expected = _dedent(
             r"""
             \begin{tabular}{lrrrrr}
             \toprule
             a & \multicolumn{2}{l}{c1} & \multicolumn{2}{l}{c2} & c3 \\
-            b &  0 &  1 &  0 &  1 &  0 \\
+            b & 0 & 1 & 0 & 1 & 0 \\
             \midrule
-            0 &  0 &  4 &  0 &  4 &  0 \\
-            1 &  1 &  5 &  1 &  5 &  1 \\
-            2 &  2 &  6 &  2 &  6 &  2 \\
-            3 &  3 &  7 &  3 &  7 &  3 \\
+            0 & 0 & 4 & 0 & 4 & 0 \\
+            1 & 1 & 5 & 1 & 5 & 1 \\
+            2 & 2 & 6 & 2 & 6 & 2 \\
+            3 & 3 & 7 & 3 & 7 & 3 \\
             \bottomrule
             \end{tabular}
             """
@@ -1161,18 +1164,18 @@ def test_to_latex_multicolumn_tabular(self, multiindex_frame):
     def test_to_latex_index_has_name_tabular(self):
         # GH 10660
         df = DataFrame({"a": [0, 0, 1, 1], "b": list("abab"), "c": [1, 2, 3, 4]})
-        result = df.set_index(["a", "b"]).to_latex()
+        result = df.set_index(["a", "b"]).to_latex(hrules=True, multirow_align="naive")
         expected = _dedent(
             r"""
             \begin{tabular}{llr}
             \toprule
-              &   &  c \\
-            a & b &    \\
+             &  & c \\
+            a & b &  \\
             \midrule
-            0 & a &  1 \\
-              & b &  2 \\
-            1 & a &  3 \\
-              & b &  4 \\
+            0 & a & 1 \\
+             & b & 2 \\
+            1 & a & 3 \\
+             & b & 4 \\
             \bottomrule
             \end{tabular}
             """
@@ -1182,17 +1185,26 @@ def test_to_latex_index_has_name_tabular(self):
     def test_to_latex_groupby_tabular(self):
         # GH 10660
         df = DataFrame({"a": [0, 0, 1, 1], "b": list("abab"), "c": [1, 2, 3, 4]})
-        result = df.groupby("a").describe().to_latex()
+        result = (
+            df.groupby("a")
+            .describe()
+            .to_latex(
+                hrules=True,
+                formatter={("c", "std"): "{:.6f}"},
+                precision=1,
+                escape=True,
+            )
+        )
         expected = _dedent(
             r"""
             \begin{tabular}{lrrrrrrrr}
             \toprule
-            {} & \multicolumn{8}{l}{c} \\
-            {} & count & mean &       std &  min &   25\% &  50\% &   75\% &  max \\
-            a &       &      &           &      &       &      &       &      \\
+             & \multicolumn{8}{r}{c} \\
+             & count & mean & std & min & 25\% & 50\% & 75\% & max \\
+            a &  &  &  &  &  &  &  &  \\
             \midrule
-            0 &   2.0 &  1.5 &  0.707107 &  1.0 &  1.25 &  1.5 &  1.75 &  2.0 \\
-            1 &   2.0 &  3.5 &  0.707107 &  3.0 &  3.25 &  3.5 &  3.75 &  4.0 \\
+            0 & 2.0 & 1.5 & 0.707107 & 1.0 & 1.2 & 1.5 & 1.8 & 2.0 \\
+            1 & 2.0 & 3.5 & 0.707107 & 3.0 & 3.2 & 3.5 & 3.8 & 4.0 \\
             \bottomrule
             \end{tabular}
             """
@@ -1210,15 +1222,15 @@ def test_to_latex_multiindex_dupe_level(self):
         df = DataFrame(
             index=pd.MultiIndex.from_tuples([("A", "c"), ("B", "c")]), columns=["col"]
         )
-        result = df.to_latex()
+        result = df.to_latex(hrules=True, na_rep="NaN")
         expected = _dedent(
             r"""
             \begin{tabular}{lll}
             \toprule
-              &   &  col \\
+             &  & col \\
             \midrule
-            A & c &  NaN \\
-            B & c &  NaN \\
+            A & c & NaN \\
+            B & c & NaN \\
             \bottomrule
             \end{tabular}
             """
@@ -1226,19 +1238,19 @@ def test_to_latex_multiindex_dupe_level(self):
         assert result == expected
 
     def test_to_latex_multicolumn_default(self, multicolumn_frame):
-        result = multicolumn_frame.to_latex()
+        result = multicolumn_frame.to_latex(hrules=True)
         expected = _dedent(
             r"""
             \begin{tabular}{lrrrrr}
             \toprule
-            {} & \multicolumn{2}{l}{c1} & \multicolumn{2}{l}{c2} & c3 \\
-            {} &  0 &  1 &  0 &  1 &  0 \\
-            \midrule
-            0 &  0 &  5 &  0 &  5 &  0 \\
-            1 &  1 &  6 &  1 &  6 &  1 \\
-            2 &  2 &  7 &  2 &  7 &  2 \\
-            3 &  3 &  8 &  3 &  8 &  3 \\
-            4 &  4 &  9 &  4 &  9 &  4 \\
+             & \multicolumn{2}{r}{c1} & \multicolumn{2}{r}{c2} & c3 \\
+             & 0 & 1 & 0 & 1 & 0 \\
+            \midrule
+            0 & 0 & 5 & 0 & 5 & 0 \\
+            1 & 1 & 6 & 1 & 6 & 1 \\
+            2 & 2 & 7 & 2 & 7 & 2 \\
+            3 & 3 & 8 & 3 & 8 & 3 \\
+            4 & 4 & 9 & 4 & 9 & 4 \\
             \bottomrule
             \end{tabular}
             """
@@ -1246,19 +1258,19 @@ def test_to_latex_multicolumn_default(self, multicolumn_frame):
         assert result == expected
 
     def test_to_latex_multicolumn_false(self, multicolumn_frame):
-        result = multicolumn_frame.to_latex(multicolumn=False)
+        result = multicolumn_frame.to_latex(multicol_align="naive-l", hrules=True)
         expected = _dedent(
             r"""
             \begin{tabular}{lrrrrr}
             \toprule
-            {} & c1 &    & c2 &    & c3 \\
-            {} &  0 &  1 &  0 &  1 &  0 \\
-            \midrule
-            0 &  0 &  5 &  0 &  5 &  0 \\
-            1 &  1 &  6 &  1 &  6 &  1 \\
-            2 &  2 &  7 &  2 &  7 &  2 \\
-            3 &  3 &  8 &  3 &  8 &  3 \\
-            4 &  4 &  9 &  4 &  9 &  4 \\
+             & c1 & & c2 & & c3 \\
+             & 0 & 1 & 0 & 1 & 0 \\
+            \midrule
+            0 & 0 & 5 & 0 & 5 & 0 \\
+            1 & 1 & 6 & 1 & 6 & 1 \\
+            2 & 2 & 7 & 2 & 7 & 2 \\
+            3 & 3 & 8 & 3 & 8 & 3 \\
+            4 & 4 & 9 & 4 & 9 & 4 \\
             \bottomrule
             \end{tabular}
             """
@@ -1266,20 +1278,18 @@ def test_to_latex_multicolumn_false(self, multicolumn_frame):
         assert result == expected
 
     def test_to_latex_multirow_true(self, multicolumn_frame):
-        result = multicolumn_frame.T.to_latex(multirow=True)
+        result = multicolumn_frame.T.to_latex(hrules=True)
         expected = _dedent(
             r"""
             \begin{tabular}{llrrrrr}
             \toprule
-               &   &  0 &  1 &  2 &  3 &  4 \\
-            \midrule
-            \multirow{2}{*}{c1} & 0 &  0 &  1 &  2 &  3 &  4 \\
-               & 1 &  5 &  6 &  7 &  8 &  9 \\
-            \cline{1-7}
-            \multirow{2}{*}{c2} & 0 &  0 &  1 &  2 &  3 &  4 \\
-               & 1 &  5 &  6 &  7 &  8 &  9 \\
-            \cline{1-7}
-            c3 & 0 &  0 &  1 &  2 &  3 &  4 \\
+             &  & 0 & 1 & 2 & 3 & 4 \\
+            \midrule
+            \multirow[c]{2}{*}{c1} & 0 & 0 & 1 & 2 & 3 & 4 \\
+             & 1 & 5 & 6 & 7 & 8 & 9 \\
+            \multirow[c]{2}{*}{c2} & 0 & 0 & 1 & 2 & 3 & 4 \\
+             & 1 & 5 & 6 & 7 & 8 & 9 \\
+            c3 & 0 & 0 & 1 & 2 & 3 & 4 \\
             \bottomrule
             \end{tabular}
             """
@@ -1289,24 +1299,22 @@ def test_to_latex_multirow_true(self, multicolumn_frame):
     def test_to_latex_multicolumnrow_with_multicol_format(self, multicolumn_frame):
         multicolumn_frame.index = multicolumn_frame.T.index
         result = multicolumn_frame.T.to_latex(
-            multirow=True,
-            multicolumn=True,
-            multicolumn_format="c",
+            multirow_align="t",
+            multicol_align="c",
+            hrules=True,
         )
         expected = _dedent(
             r"""
             \begin{tabular}{llrrrrr}
             \toprule
-               &   & \multicolumn{2}{c}{c1} & \multicolumn{2}{c}{c2} & c3 \\
-               &   &  0 &  1 &  0 &  1 &  0 \\
-            \midrule
-            \multirow{2}{*}{c1} & 0 &  0 &  1 &  2 &  3 &  4 \\
-               & 1 &  5 &  6 &  7 &  8 &  9 \\
-            \cline{1-7}
-            \multirow{2}{*}{c2} & 0 &  0 &  1 &  2 &  3 &  4 \\
-               & 1 &  5 &  6 &  7 &  8 &  9 \\
-            \cline{1-7}
-            c3 & 0 &  0 &  1 &  2 &  3 &  4 \\
+             &  & \multicolumn{2}{c}{c1} & \multicolumn{2}{c}{c2} & c3 \\
+             &  & 0 & 1 & 0 & 1 & 0 \\
+            \midrule
+            \multirow[t]{2}{*}{c1} & 0 & 0 & 1 & 2 & 3 & 4 \\
+             & 1 & 5 & 6 & 7 & 8 & 9 \\
+            \multirow[t]{2}{*}{c2} & 0 & 0 & 1 & 2 & 3 & 4 \\
+             & 1 & 5 & 6 & 7 & 8 & 9 \\
+            c3 & 0 & 0 & 1 & 2 & 3 & 4 \\
             \bottomrule
             \end{tabular}
             """
@@ -1324,28 +1332,36 @@ def test_to_latex_multiindex_names(self, name0, name1, axes):
         for idx in axes:
             df.axes[idx].names = names
 
-        idx_names = tuple(n or "{}" for n in names)
-        idx_names_row = (
-            f"{idx_names[0]} & {idx_names[1]} &    &    &    &    \\\\\n"
-            if (0 in axes and any(names))
+        index_names_row = (
+            f"{{{name0 if name0 else ''}}} & {{{name1 if name1 else ''}}} & {{}} & "
+            f"{{}} & {{}} & {{}} \\\\\n"
+            if (0 in axes and (name0 is not None or name1 is not None))
             else ""
         )
-        placeholder = "{}" if any(names) and 1 in axes else " "
-        col_names = [n if (bool(n) and 1 in axes) else placeholder for n in names]
-        observed = df.to_latex()
-        expected = r"""\begin{tabular}{llrrrr}
-\toprule
-  & %s & \multicolumn{2}{l}{1} & \multicolumn{2}{l}{2} \\
-  & %s &  3 &  4 &  3 &  4 \\
-%s\midrule
-1 & 3 & -1 & -1 & -1 & -1 \\
-  & 4 & -1 & -1 & -1 & -1 \\
-2 & 3 & -1 & -1 & -1 & -1 \\
-  & 4 & -1 & -1 & -1 & -1 \\
-\bottomrule
-\end{tabular}
-""" % tuple(
-            list(col_names) + [idx_names_row]
+        column_name0 = f"{{{name0 if (name0 and 1 in axes) else ''}}}"
+        column_name1 = f"{{{name1 if (name1 and 1 in axes) else ''}}}"
+
+        observed = df.to_latex(
+            hrules=True,
+            multicol_align="l",
+            sparse_columns=False,
+            sparse_index=False,
+            siunitx=True,
+        )
+        expected = dedent(
+            f"""\
+\\begin{{tabular}}{{llSSSS}}
+\\toprule
+{{}} & {column_name0} & {{1}} & {{1}} & {{2}} & {{2}} \\\\
+{{}} & {column_name1} & {{3}} & {{4}} & {{3}} & {{4}} \\\\
+{index_names_row}\\midrule
+1 & 3 & -1 & -1 & -1 & -1 \\\\
+1 & 4 & -1 & -1 & -1 & -1 \\\\
+2 & 3 & -1 & -1 & -1 & -1 \\\\
+2 & 4 & -1 & -1 & -1 & -1 \\\\
+\\bottomrule
+\\end{{tabular}}
+"""
         )
         assert observed == expected
 
@@ -1355,19 +1371,21 @@ def test_to_latex_multiindex_nans(self, one_row):
         df = DataFrame({"a": [None, 1], "b": [2, 3], "c": [4, 5]})
         if one_row:
             df = df.iloc[[0]]
-        observed = df.set_index(["a", "b"]).to_latex()
+        observed = df.set_index(["a", "b"]).to_latex(
+            hrules=True, na_rep="NaN", precision=1
+        )
         expected = _dedent(
             r"""
             \begin{tabular}{llr}
             \toprule
-                &   &  c \\
-            a & b &    \\
+             &  & c \\
+            a & b &  \\
             \midrule
-            NaN & 2 &  4 \\
+            NaN & 2 & 4 \\
             """
         )
         if not one_row:
-            expected += r"""1.0 & 3 &  5 \\
+            expected += r"""1.0 & 3 & 5 \\
 """
         expected += r"""\bottomrule
 \end{tabular}
@@ -1377,16 +1395,16 @@ def test_to_latex_multiindex_nans(self, one_row):
     def test_to_latex_non_string_index(self):
         # GH 19981
         df = DataFrame([[1, 2, 3]] * 2).set_index([0, 1])
-        result = df.to_latex()
+        result = df.to_latex(hrules=True, multirow_align="naive")
         expected = _dedent(
             r"""
             \begin{tabular}{llr}
             \toprule
-              &   &  2 \\
-            0 & 1 &    \\
+             &  & 2 \\
+            0 & 1 &  \\
             \midrule
-            1 & 2 &  3 \\
-              & 2 &  3 \\
+            1 & 2 & 3 \\
+             & 2 & 3 \\
             \bottomrule
             \end{tabular}
             """
@@ -1399,32 +1417,25 @@ def test_to_latex_multiindex_multirow(self):
             [[0.0, 1.0], [3.0, 2.0, 1.0], ["0", "1"]], names=["i", "val0", "val1"]
         )
         df = DataFrame(index=mi)
-        result = df.to_latex(multirow=True, escape=False)
+        result = df.to_latex(escape=False, precision=1, hrules=True)
         expected = _dedent(
             r"""
             \begin{tabular}{lll}
             \toprule
-                &     &   \\
             i & val0 & val1 \\
             \midrule
-            \multirow{6}{*}{0.0} & \multirow{2}{*}{3.0} & 0 \\
-                &     & 1 \\
-            \cline{2-3}
-                & \multirow{2}{*}{2.0} & 0 \\
-                &     & 1 \\
-            \cline{2-3}
-                & \multirow{2}{*}{1.0} & 0 \\
-                &     & 1 \\
-            \cline{1-3}
-            \cline{2-3}
-            \multirow{6}{*}{1.0} & \multirow{2}{*}{3.0} & 0 \\
-                &     & 1 \\
-            \cline{2-3}
-                & \multirow{2}{*}{2.0} & 0 \\
-                &     & 1 \\
-            \cline{2-3}
-                & \multirow{2}{*}{1.0} & 0 \\
-                &     & 1 \\
+            \multirow[c]{6}{*}{0.0} & \multirow[c]{2}{*}{3.0} & 0 \\
+             &  & 1 \\
+             & \multirow[c]{2}{*}{2.0} & 0 \\
+             &  & 1 \\
+             & \multirow[c]{2}{*}{1.0} & 0 \\
+             &  & 1 \\
+            \multirow[c]{6}{*}{1.0} & \multirow[c]{2}{*}{3.0} & 0 \\
+             &  & 1 \\
+             & \multirow[c]{2}{*}{2.0} & 0 \\
+             &  & 1 \\
+             & \multirow[c]{2}{*}{1.0} & 0 \\
+             &  & 1 \\
             \bottomrule
             \end{tabular}
             """
@@ -1514,3 +1525,24 @@ def test_get_strrow_multindex_multicolumn(self, row_num, expected):
         )
 
         assert row_string_converter.get_strrow(row_num=row_num) == expected
+
+
+@pytest.mark.parametrize(
+    "deprecated",
+    [
+        "longtable",
+        "multicolumn",
+        "multicolumn_format",
+        "multirow",
+        "col_space",
+        "formatters",
+        "float_format",
+        "sparsify",
+        "bold_rows",
+    ],
+)
+def test_deprecation_warning(deprecated):
+    df = DataFrame([[1]])
+    msg = f"`{deprecated}` is deprecated"
+    with tm.assert_produces_warning(FutureWarning, match=msg):
+        df.to_latex(**{deprecated: "some_value_not_None"})
diff --git a/pandas/tests/series/test_repr.py b/pandas/tests/series/test_repr.py
index 555342dd39005..8969deb7b7a9e 100644
--- a/pandas/tests/series/test_repr.py
+++ b/pandas/tests/series/test_repr.py
@@ -198,16 +198,13 @@ def test_timeseries_repr_object_dtype(self):
 
     def test_latex_repr(self):
         result = r"""\begin{tabular}{ll}
-\toprule
-{} &         0 \\
-\midrule
-0 &  $\alpha$ \\
-1 &         b \\
-2 &         c \\
-\bottomrule
+ & 0 \\
+0 & $\alpha$ \\
+1 & b \\
+2 & c \\
 \end{tabular}
 """
-        with option_context("display.latex.escape", False, "display.latex.repr", True):
+        with option_context("styler.render.repr", "latex"):
             s = Series([r"$\alpha$", "b", "c"])
             assert result == s._repr_latex_()
 
diff --git a/requirements-dev.txt b/requirements-dev.txt
index 9b35de4bccb48..218bf15865064 100644
--- a/requirements-dev.txt
+++ b/requirements-dev.txt
@@ -4,6 +4,7 @@
 numpy>=1.18.5
 python-dateutil>=2.8.1
 pytz
+jinja2
 asv
 cython>=0.29.21
 black==21.5b2
@@ -51,7 +52,6 @@ blosc
 bottleneck>=1.3.1
 ipykernel
 ipython>=7.11.1
-jinja2
 matplotlib>=3.3.2
 numexpr>=2.7.1
 scipy>=1.4.1
diff --git a/setup.cfg b/setup.cfg
index 62ff0c6934f77..dcd2d3e4d2128 100644
--- a/setup.cfg
+++ b/setup.cfg
@@ -33,6 +33,7 @@ install_requires =
     numpy>=1.18.5
     python-dateutil>=2.8.1
     pytz>=2020.1
+    jinja2>=2.11
 python_requires = >=3.8
 include_package_data = True
 zip_safe = False