diff --git a/doc/source/_static/style/latex_1.png b/doc/source/_static/style/latex_1.png
new file mode 100644
index 0000000000000..8b901878a0ec9
Binary files /dev/null and b/doc/source/_static/style/latex_1.png differ
diff --git a/doc/source/_static/style/latex_2.png b/doc/source/_static/style/latex_2.png
new file mode 100644
index 0000000000000..7d6baa681575e
Binary files /dev/null and b/doc/source/_static/style/latex_2.png differ
diff --git a/doc/source/reference/style.rst b/doc/source/reference/style.rst
index 8c443f3ae9bb6..6a075ad702bde 100644
--- a/doc/source/reference/style.rst
+++ b/doc/source/reference/style.rst
@@ -24,6 +24,7 @@ Styler properties
 
    Styler.env
    Styler.template_html
+   Styler.template_latex
    Styler.loader
 
 Style application
@@ -66,3 +67,4 @@ Style export and import
    Styler.export
    Styler.use
    Styler.to_excel
+   Styler.to_latex
diff --git a/doc/source/whatsnew/v1.3.0.rst b/doc/source/whatsnew/v1.3.0.rst
index 4abc190bae70f..a48074789f727 100644
--- a/doc/source/whatsnew/v1.3.0.rst
+++ b/doc/source/whatsnew/v1.3.0.rst
@@ -141,6 +141,9 @@ properly format HTML and eliminate some inconsistencies (:issue:`39942` :issue:`
 :class:`.Styler` has also been compatible with non-unique index or columns, at least for as many features as are fully compatible, others made only partially compatible (:issue:`41269`).
 One also has greater control of the display through separate sparsification of the index or columns, using the new 'styler' options context (:issue:`41142`).
 
+We have added an extension to allow LaTeX styling as an alternative to CSS styling and a method :meth:`.Styler.to_latex`
+which renders the necessary LaTeX format including built-up styles.
+
 Documentation has also seen major revisions in light of new features (:issue:`39720` :issue:`39317` :issue:`40493`)
 
 .. _whatsnew_130.dataframe_honors_copy_with_dict:
diff --git a/pandas/io/formats/style.py b/pandas/io/formats/style.py
index 56e34d9500f31..977a3a24f0844 100644
--- a/pandas/io/formats/style.py
+++ b/pandas/io/formats/style.py
@@ -21,6 +21,7 @@
 
 from pandas._typing import (
     Axis,
+    FilePathOrBuffer,
     FrameOrSeries,
     FrameOrSeriesUnion,
     IndexLabel,
@@ -30,6 +31,7 @@
 from pandas.util._decorators import doc
 
 import pandas as pd
+from pandas import RangeIndex
 from pandas.api.types import is_list_like
 from pandas.core import generic
 import pandas.core.common as com
@@ -39,6 +41,8 @@
 )
 from pandas.core.generic import NDFrame
 
+from pandas.io.formats.format import save_to_buffer
+
 jinja2 = import_optional_dependency("jinja2", extra="DataFrame.style requires jinja2.")
 
 from pandas.io.formats.style_render import (
@@ -403,6 +407,338 @@ def to_excel(
             engine=engine,
         )
 
+    def to_latex(
+        self,
+        buf: FilePathOrBuffer[str] | None = None,
+        *,
+        column_format: str | None = None,
+        position: str | None = None,
+        position_float: str | None = None,
+        hrules: bool = False,
+        label: str | None = None,
+        caption: str | None = None,
+        sparse_index: bool | None = None,
+        sparse_columns: bool | None = None,
+        multirow_align: str = "c",
+        multicol_align: str = "r",
+        siunitx: bool = False,
+        encoding: str | None = None,
+    ):
+        r"""
+        Write Styler to a file, buffer or string in LaTeX format.
+
+        .. versionadded:: 1.3.0
+
+        Parameters
+        ----------
+        buf : str, Path, or StringIO-like, optional, default None
+            Buffer to write to. If ``None``, the output is returned as a string.
+        column_format : str, optional
+            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``.
+        position : str, optional
+            The LaTeX positional argument (e.g. 'h!') for tables, placed in location:
+
+            \\begin{table}[<position>]
+        position_float : {"centering", "raggedleft", "raggedright"}, optional
+            The LaTeX float command placed in location:
+
+            \\begin{table}[<position>]
+
+            \\<position_float>
+        hrules : bool, default False
+            Set to `True` to add \\toprule, \\midrule and \\bottomrule from the
+            {booktabs} LaTeX package.
+        label : str, optional
+            The LaTeX label included as: \\label{<label>}.
+            This is used with \\ref{<label>} in the main .tex file.
+        caption : str, optional
+            The LaTeX table caption included as: \\caption{<caption>}.
+        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`` value.
+        sparse_columns : 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.columns`` value.
+        multirow_align : {"c", "t", "b"}
+            If sparsifying hierarchical MultiIndexes whether to align text centrally,
+            at the top or bottom.
+        multicol_align : {"r", "c", "l"}
+            If sparsifying hierarchical MultiIndex columns whether to align text at
+            the left, centrally, or at the right.
+        siunitx : bool, default False
+            Set to ``True`` to structure LaTeX compatible with the {siunitx} package.
+        encoding : str, default "utf-8"
+            Character encoding setting.
+
+        Returns
+        -------
+        str or None
+            If `buf` is None, returns the result as a string. Otherwise returns `None`.
+
+        See Also
+        --------
+        Styler.format: Format the text display value of cells.
+
+        Notes
+        -----
+        **Latex Packages**
+
+        For the following features we recommend the following LaTeX inclusions:
+
+        ===================== ==========================================================
+        Feature               Inclusion
+        ===================== ==========================================================
+        sparse columns        none: included within default {tabular} environment
+        sparse rows           \\usepackage{multirow}
+        hrules                \\usepackage{booktabs}
+        colors                \\usepackage[table]{xcolor}
+        siunitx               \\usepackage{siunitx}
+        bold (with siunitx)   | \\usepackage{etoolbox}
+                              | \\robustify\\bfseries
+                              | \\sisetup{detect-all = true}  *(within {document})*
+        italic (with siunitx) | \\usepackage{etoolbox}
+                              | \\robustify\\itshape
+                              | \\sisetup{detect-all = true}  *(within {document})*
+        ===================== ==========================================================
+
+        **Cell Styles**
+
+        LaTeX styling can only be rendered if the accompanying styling functions have
+        been constructed with appropriate LaTeX commands. All styling
+        functionality is built around the concept of a CSS ``(<attribute>, <value>)``
+        pair (see `Table Visualization <../../user_guide/style.ipynb>`_), and this
+        should be replaced by a LaTeX
+        ``(<command>, <options>)`` approach. Each cell will be styled individually
+        using nested LaTeX commands with their accompanied options.
+
+        For example the following code will highlight and bold a cell in HTML-CSS:
+
+        >>> df = pd.DataFrame([[1,2], [3,4]])
+        >>> s = df.style.highlight_max(axis=None,
+        ...                            props='background-color:red; font-weight:bold;')
+        >>> s.render()
+
+        The equivalent using LaTeX only commands is the following:
+
+        >>> s = df.style.highlight_max(axis=None,
+        ...                            props='cellcolor:{red}; bfseries: ;')
+        >>> s.to_latex()
+
+        Internally these structured LaTeX ``(<command>, <options>)`` pairs
+        are translated to the
+        ``display_value`` with the default structure:
+        ``\<command><options> <display_value>``.
+        Where there are multiple commands the latter is nested recursively, so that
+        the above example highlighed cell is rendered as
+        ``\cellcolor{red} \bfseries 4``.
+
+        Occasionally this format does not suit the applied command, or
+        combination of LaTeX packages that is in use, so additional flags can be
+        added to the ``<options>``, within the tuple, to result in different
+        positions of required braces (the **default** being the same as ``--nowrap``):
+
+        =================================== ============================================
+        Tuple Format                           Output Structure
+        =================================== ============================================
+        (<command>,<options>)               \\<command><options> <display_value>
+        (<command>,<options> ``--nowrap``)  \\<command><options> <display_value>
+        (<command>,<options> ``--rwrap``)   \\<command><options>{<display_value>}
+        (<command>,<options> ``--wrap``)    {\\<command><options> <display_value>}
+        (<command>,<options> ``--lwrap``)   {\\<command><options>} <display_value>
+        (<command>,<options> ``--dwrap``)   {\\<command><options>}{<display_value>}
+        =================================== ============================================
+
+        For example the `textbf` command for font-weight
+        should always be used with `--rwrap` so ``('textbf', '--rwrap')`` will render a
+        working cell, wrapped with braces, as ``\textbf{<display_value>}``.
+
+        A more comprehensive example is as follows:
+
+        >>> df = pd.DataFrame([[1, 2.2, "dogs"], [3, 4.4, "cats"], [2, 6.6, "cows"]],
+        ...                   index=["ix1", "ix2", "ix3"],
+        ...                   columns=["Integers", "Floats", "Strings"])
+        >>> s = df.style.highlight_max(
+        ...     props='cellcolor:[HTML]{FFFF00}; color:{red};'
+        ...           'textit:--rwrap; textbf:--rwrap;'
+        ... )
+        >>> s.to_latex()
+
+        .. figure:: ../../_static/style/latex_1.png
+
+        **Table Styles**
+
+        Internally Styler uses its ``table_styles`` object to parse the
+        ``column_format``, ``position``, ``position_float``, and ``label``
+        input arguments. These arguments are added to table styles in the format:
+
+        .. code-block:: python
+
+            set_table_styles([
+                {"selector": "column_format", "props": f":{column_format};"},
+                {"selector": "position", "props": f":{position};"},
+                {"selector": "position_float", "props": f":{position_float};"},
+                {"selector": "label", "props": f":{{{label.replace(':','§')}}};"}
+            ], overwrite=False)
+
+        Exception is made for the ``hrules`` argument which, in fact, controls all three
+        commands: ``toprule``, ``bottomrule`` and ``midrule`` simultaneously. Instead of
+        setting ``hrules`` to ``True``, it is also possible to set each
+        individual rule definition, by manually setting the ``table_styles``,
+        for example below we set a regular ``toprule``, set an ``hline`` for
+        ``bottomrule`` and exclude the ``midrule``:
+
+        .. code-block:: python
+
+            set_table_styles([
+                {'selector': 'toprule', 'props': ':toprule;'},
+                {'selector': 'bottomrule', 'props': ':hline;'},
+            ], overwrite=False)
+
+        If other ``commands`` are added to table styles they will be detected, and
+        positioned immediately above the '\\begin{tabular}' command. For example to
+        add odd and even row coloring, from the {colortbl} package, in format
+        ``\rowcolors{1}{pink}{red}``, use:
+
+        .. code-block:: python
+
+            set_table_styles([
+                {'selector': 'rowcolors', 'props': ':{1}{pink}{red};'}
+            ], overwrite=False)
+
+        A more comprehensive example using these arguments is as follows:
+
+        >>> df.columns = pd.MultiIndex.from_tuples([
+        ...     ("Numeric", "Integers"),
+        ...     ("Numeric", "Floats"),
+        ...     ("Non-Numeric", "Strings")
+        ... ])
+        >>> df.index = pd.MultiIndex.from_tuples([
+        ...     ("L0", "ix1"), ("L0", "ix2"), ("L1", "ix3")
+        ... ])
+        >>> s = df.style.highlight_max(
+        ...     props='cellcolor:[HTML]{FFFF00}; color:{red}; itshape:; bfseries:;'
+        ... )
+        >>> s.to_latex(
+        ...     column_format="rrrrr", position="h", position_float="centering",
+        ...     hrules=True, label="table:5", caption="Styled LaTeX Table",
+        ...     multirow_align="t", multicol_align="r"
+        ... )
+
+        .. figure:: ../../_static/style/latex_2.png
+
+        **Formatting**
+
+        To format values :meth:`Styler.format` should be used prior to calling
+        `Styler.to_latex`, as well as other methods such as :meth:`Styler.hide_index`
+        or :meth:`Styler.hide_columns`, for example:
+
+        >>> s.clear()
+        >>> s.table_styles = []
+        >>> s.caption = None
+        >>> s.format({
+        ...    ("Numeric", "Integers"): '\${}',
+        ...    ("Numeric", "Floats"): '{:.3f}',
+        ...    ("Non-Numeric", "Strings"): str.upper
+        ... })
+        >>> s.to_latex()
+        \begin{tabular}{llrrl}
+        {} & {} & \multicolumn{2}{r}{Numeric} & {Non-Numeric} \\
+        {} & {} & {Integers} & {Floats} & {Strings} \\
+        \multirow[c]{2}{*}{L0} & ix1 & \\$1 & 2.200 & DOGS \\
+         & ix2 & \$3 & 4.400 & CATS \\
+        L1 & ix3 & \$2 & 6.600 & COWS \\
+        \end{tabular}
+        """
+        table_selectors = (
+            [style["selector"] for style in self.table_styles]
+            if self.table_styles is not None
+            else []
+        )
+
+        if column_format is not None:
+            # add more recent setting to table_styles
+            self.set_table_styles(
+                [{"selector": "column_format", "props": f":{column_format}"}],
+                overwrite=False,
+            )
+        elif "column_format" in table_selectors:
+            pass  # adopt what has been previously set in table_styles
+        else:
+            # create a default: set float, complex, int cols to 'r' ('S'), index to 'l'
+            _original_columns = self.data.columns
+            self.data.columns = RangeIndex(stop=len(self.data.columns))
+            numeric_cols = self.data._get_numeric_data().columns.to_list()
+            self.data.columns = _original_columns
+            column_format = "" if self.hidden_index else "l" * self.data.index.nlevels
+            for ci, _ in enumerate(self.data.columns):
+                if ci not in self.hidden_columns:
+                    column_format += (
+                        ("r" if not siunitx else "S") if ci in numeric_cols else "l"
+                    )
+            self.set_table_styles(
+                [{"selector": "column_format", "props": f":{column_format}"}],
+                overwrite=False,
+            )
+
+        if position:
+            self.set_table_styles(
+                [{"selector": "position", "props": f":{position}"}],
+                overwrite=False,
+            )
+
+        if position_float:
+            if position_float not in ["raggedright", "raggedleft", "centering"]:
+                raise ValueError(
+                    f"`position_float` should be one of "
+                    f"'raggedright', 'raggedleft', 'centering', "
+                    f"got: '{position_float}'"
+                )
+            self.set_table_styles(
+                [{"selector": "position_float", "props": f":{position_float}"}],
+                overwrite=False,
+            )
+
+        if hrules:
+            self.set_table_styles(
+                [
+                    {"selector": "toprule", "props": ":toprule"},
+                    {"selector": "midrule", "props": ":midrule"},
+                    {"selector": "bottomrule", "props": ":bottomrule"},
+                ],
+                overwrite=False,
+            )
+
+        if label:
+            self.set_table_styles(
+                [{"selector": "label", "props": f":{{{label.replace(':', '§')}}}"}],
+                overwrite=False,
+            )
+
+        if caption:
+            self.set_caption(caption)
+
+        if sparse_index is None:
+            sparse_index = get_option("styler.sparse.index")
+        if sparse_columns is None:
+            sparse_columns = get_option("styler.sparse.columns")
+
+        latex = self._render_latex(
+            sparse_index=sparse_index,
+            sparse_columns=sparse_columns,
+            multirow_align=multirow_align,
+            multicol_align=multicol_align,
+        )
+
+        return save_to_buffer(latex, buf=buf, encoding=encoding)
+
     def set_td_classes(self, classes: DataFrame) -> Styler:
         """
         Set the DataFrame of strings added to the ``class`` attribute of ``<td>``
diff --git a/pandas/io/formats/style_render.py b/pandas/io/formats/style_render.py
index 9d149008dcb88..ce328f00cf794 100644
--- a/pandas/io/formats/style_render.py
+++ b/pandas/io/formats/style_render.py
@@ -66,6 +66,7 @@ class StylerRenderer:
     loader = jinja2.PackageLoader("pandas", "io/formats/templates")
     env = jinja2.Environment(loader=loader, trim_blocks=True)
     template_html = env.get_template("html.tpl")
+    template_latex = env.get_template("latex.tpl")
 
     def __init__(
         self,
@@ -118,6 +119,23 @@ def _render_html(self, sparse_index: bool, sparse_columns: bool, **kwargs) -> st
         d.update(kwargs)
         return self.template_html.render(**d)
 
+    def _render_latex(self, sparse_index: bool, sparse_columns: bool, **kwargs) -> str:
+        """
+        Render a Styler in latex format
+        """
+        self._compute()
+
+        d = self._translate(sparse_index, sparse_columns, blank="")
+        self._translate_latex(d)
+
+        self.template_latex.globals["parse_wrap"] = _parse_latex_table_wrapping
+        self.template_latex.globals["parse_table"] = _parse_latex_table_styles
+        self.template_latex.globals["parse_cell"] = _parse_latex_cell_styles
+        self.template_latex.globals["parse_header"] = _parse_latex_header_span
+
+        d.update(kwargs)
+        return self.template_latex.render(**d)
+
     def _compute(self):
         """
         Execute the style functions built up in `self._todo`.
@@ -133,7 +151,7 @@ def _compute(self):
             r = func(self)(*args, **kwargs)
         return r
 
-    def _translate(self, sparse_index: bool, sparse_cols: bool):
+    def _translate(self, sparse_index: bool, sparse_cols: bool, blank: str = "&nbsp;"):
         """
         Process Styler data and settings into a dict for template rendering.
 
@@ -161,7 +179,7 @@ def _translate(self, sparse_index: bool, sparse_cols: bool):
 
         DATA_CLASS = "data"
         BLANK_CLASS = "blank"
-        BLANK_VALUE = "&nbsp;"
+        BLANK_VALUE = blank
 
         # construct render dict
         d = {
@@ -395,6 +413,42 @@ def _translate_body(
             body.append(index_headers + data)
         return body
 
+    def _translate_latex(self, d: dict) -> None:
+        r"""
+        Post-process the default render dict for the LaTeX template format.
+
+        Processing items included are:
+          - Remove hidden columns from the non-headers part of the body.
+          - Place cellstyles directly in td cells rather than use cellstyle_map.
+          - Remove hidden indexes or reinsert missing th elements if part of multiindex
+            or multirow sparsification (so that \multirow and \multicol work correctly).
+        """
+        d["head"] = [[col for col in row if col["is_visible"]] for row in d["head"]]
+        body = []
+        for r, row in enumerate(d["body"]):
+            if self.hidden_index:
+                row_body_headers = []
+            else:
+                row_body_headers = [
+                    {
+                        **col,
+                        "display_value": col["display_value"]
+                        if col["is_visible"]
+                        else "",
+                    }
+                    for col in row
+                    if col["type"] == "th"
+                ]
+
+            row_body_cells = [
+                {**col, "cellstyle": self.ctx[r, c - self.data.index.nlevels]}
+                for c, col in enumerate(row)
+                if (col["is_visible"] and col["type"] == "td")
+            ]
+
+            body.append(row_body_headers + row_body_cells)
+        d["body"] = body
+
     def format(
         self,
         formatter: ExtFormatter | None = None,
@@ -996,3 +1050,140 @@ def _translate(self, styler_data: FrameOrSeriesUnion, uuid: str, d: dict):
             d["table_styles"].extend(self.table_styles)
 
         return d
+
+
+def _parse_latex_table_wrapping(table_styles: CSSStyles, caption: str | None) -> bool:
+    """
+    Indicate whether LaTeX {tabular} should be wrapped with a {table} environment.
+
+    Parses the `table_styles` and detects any selectors which must be included outside
+    of {tabular}, i.e. indicating that wrapping must occur, and therefore return True,
+    or if a caption exists and requires similar.
+    """
+    IGNORED_WRAPPERS = ["toprule", "midrule", "bottomrule", "column_format"]
+    # ignored selectors are included with {tabular} so do not need wrapping
+    return (
+        table_styles is not None
+        and any(d["selector"] not in IGNORED_WRAPPERS for d in table_styles)
+    ) or caption is not None
+
+
+def _parse_latex_table_styles(table_styles: CSSStyles, selector: str) -> str | None:
+    """
+    Return the first 'props' 'value' from ``tables_styles`` identified by ``selector``.
+
+    Examples
+    --------
+    >>> table_styles = [{'selector': 'foo', 'props': [('attr','value')],
+    ...                 {'selector': 'bar', 'props': [('attr', 'overwritten')]},
+    ...                 {'selector': 'bar', 'props': [('a1', 'baz'), ('a2', 'ignore')]}]
+    >>> _parse_latex_table_styles(table_styles, selector='bar')
+    'baz'
+
+    Notes
+    -----
+    The replacement of "§" with ":" is to avoid the CSS problem where ":" has structural
+    significance and cannot be used in LaTeX labels, but is often required by them.
+    """
+    for style in table_styles[::-1]:  # in reverse for most recently applied style
+        if style["selector"] == selector:
+            return str(style["props"][0][1]).replace("§", ":")
+    return None
+
+
+def _parse_latex_cell_styles(latex_styles: CSSList, display_value: str) -> str:
+    r"""
+    Mutate the ``display_value`` string including LaTeX commands from ``latex_styles``.
+
+    This method builds a recursive latex chain of commands based on the
+    CSSList input, nested around ``display_value``.
+
+    If a CSS style is given as ('<command>', '<options>') this is translated to
+    '\<command><options>{display_value}', and this value is treated as the
+    display value for the next iteration.
+
+    The most recent style forms the inner component, for example for styles:
+    `[('c1', 'o1'), ('c2', 'o2')]` this returns: `\c1o1{\c2o2{display_value}}`
+
+    Sometimes latex commands have to be wrapped with curly braces in different ways:
+    We create some parsing flags to identify the different behaviours:
+
+     - `--rwrap`        : `\<command><options>{<display_value>}`
+     - `--wrap`         : `{\<command><options> <display_value>}`
+     - `--nowrap`       : `\<command><options> <display_value>`
+     - `--lwrap`        : `{\<command><options>} <display_value>`
+     - `--dwrap`        : `{\<command><options>}{<display_value>}`
+
+    For example for styles:
+    `[('c1', 'o1--wrap'), ('c2', 'o2')]` this returns: `{\c1o1 \c2o2{display_value}}
+    """
+    for (command, options) in latex_styles[::-1]:  # in reverse for most recent style
+        formatter = {
+            "--wrap": f"{{\\{command}--to_parse {display_value}}}",
+            "--nowrap": f"\\{command}--to_parse {display_value}",
+            "--lwrap": f"{{\\{command}--to_parse}} {display_value}",
+            "--rwrap": f"\\{command}--to_parse{{{display_value}}}",
+            "--dwrap": f"{{\\{command}--to_parse}}{{{display_value}}}",
+        }
+        display_value = f"\\{command}{options} {display_value}"
+        for arg in ["--nowrap", "--wrap", "--lwrap", "--rwrap", "--dwrap"]:
+            if arg in str(options):
+                display_value = formatter[arg].replace(
+                    "--to_parse", _parse_latex_options_strip(value=options, arg=arg)
+                )
+                break  # only ever one purposeful entry
+    return display_value
+
+
+def _parse_latex_header_span(
+    cell: dict[str, Any], multirow_align: str, multicol_align: str, wrap: bool = False
+) -> str:
+    r"""
+    Refactor the cell `display_value` if a 'colspan' or 'rowspan' attribute is present.
+
+    'rowspan' and 'colspan' do not occur simultaneouly. If they are detected then
+    the `display_value` is altered to a LaTeX `multirow` or `multicol` command
+    respectively, with the appropriate cell-span.
+
+    ``wrap`` is used to enclose the `display_value` in braces which is needed for
+    column headers using an siunitx package.
+
+    Requires the package {multirow}, whereas multicol support is usually built in
+    to the {tabular} environment.
+
+    Examples
+    --------
+    >>> cell = {'display_vale':'text', 'attributes': 'colspan="3"'}
+    >>> _parse_latex_header_span(cell, 't', 'c')
+    '\multicol{3}{c}{text}'
+    """
+    if "attributes" in cell:
+        attrs = cell["attributes"]
+        if 'colspan="' in attrs:
+            colspan = attrs[attrs.find('colspan="') + 9 :]  # len('colspan="') = 9
+            colspan = int(colspan[: colspan.find('"')])
+            return (
+                f"\\multicolumn{{{colspan}}}{{{multicol_align}}}"
+                f"{{{cell['display_value']}}}"
+            )
+        elif 'rowspan="' in attrs:
+            rowspan = attrs[attrs.find('rowspan="') + 9 :]
+            rowspan = int(rowspan[: rowspan.find('"')])
+            return (
+                f"\\multirow[{multirow_align}]{{{rowspan}}}{{*}}"
+                f"{{{cell['display_value']}}}"
+            )
+    if wrap:
+        return f"{{{cell['display_value']}}}"
+    else:
+        return cell["display_value"]
+
+
+def _parse_latex_options_strip(value: str | int | float, arg: str) -> str:
+    """
+    Strip a css_value which may have latex wrapping arguments, css comment identifiers,
+    and whitespaces, to a valid string for latex options parsing.
+
+    For example: 'red /* --wrap */  ' --> 'red'
+    """
+    return str(value).replace(arg, "").replace("/*", "").replace("*/", "").strip()
diff --git a/pandas/io/formats/templates/latex.tpl b/pandas/io/formats/templates/latex.tpl
new file mode 100644
index 0000000000000..e5db6ad8ca7f8
--- /dev/null
+++ b/pandas/io/formats/templates/latex.tpl
@@ -0,0 +1,49 @@
+{% if parse_wrap(table_styles, caption) %}
+\begin{table}
+{%- set position = parse_table(table_styles, 'position') %}
+{%- if position is not none %}
+[{{position}}]
+{%- endif %}
+
+{% set position_float = parse_table(table_styles, 'position_float') %}
+{% if position_float is not none%}
+\{{position_float}}
+{% endif %}
+{% if caption %}
+\caption{% raw %}{{% endraw %}{{caption}}{% raw %}}{% endraw %}
+
+{% endif %}
+{% for style in table_styles %}
+{% if style['selector'] not in ['position', 'position_float', 'caption', 'toprule', 'midrule', 'bottomrule', 'column_format'] %}
+\{{style['selector']}}{{parse_table(table_styles, style['selector'])}}
+{% endif %}
+{% endfor %}
+{% endif %}
+\begin{tabular}
+{%- set column_format = parse_table(table_styles, 'column_format') %}
+{% raw %}{{% endraw %}{{column_format}}{% raw %}}{% endraw %}
+
+{% set toprule = parse_table(table_styles, 'toprule') %}
+{% if toprule is not none %}
+\{{toprule}}
+{% endif %}
+{% for row in head %}
+{% for c in row %}{%- if not loop.first %} & {% endif %}{{parse_header(c, multirow_align, multicol_align, True)}}{% endfor %} \\
+{% endfor %}
+{% set midrule = parse_table(table_styles, 'midrule') %}
+{% if midrule is not none %}
+\{{midrule}}
+{% endif %}
+{% for row in body %}
+{% for c in row %}{% if not loop.first %} & {% endif %}
+  {%- if c.type == 'th' %}{{parse_header(c, multirow_align, multicol_align)}}{% else %}{{parse_cell(c.cellstyle, c.display_value)}}{% endif %}
+{%- endfor %} \\
+{% endfor %}
+{% set bottomrule = parse_table(table_styles, 'bottomrule') %}
+{% if bottomrule is not none %}
+\{{bottomrule}}
+{% endif %}
+\end{tabular}
+{% if parse_wrap(table_styles, caption) %}
+\end{table}
+{% endif %}
diff --git a/pandas/tests/io/formats/style/test_non_unique.py b/pandas/tests/io/formats/style/test_non_unique.py
index 9cbc2db87fbde..fc04169091c09 100644
--- a/pandas/tests/io/formats/style/test_non_unique.py
+++ b/pandas/tests/io/formats/style/test_non_unique.py
@@ -1,3 +1,5 @@
+from textwrap import dedent
+
 import pytest
 
 from pandas import (
@@ -122,3 +124,17 @@ def test_hide_columns_non_unique(styler):
     assert ctx["body"][0][1]["is_visible"] is True
     assert ctx["body"][0][2]["is_visible"] is False
     assert ctx["body"][0][3]["is_visible"] is False
+
+
+def test_latex_non_unique(styler):
+    result = styler.to_latex()
+    assert result == dedent(
+        """\
+        \\begin{tabular}{lrrr}
+        {} & {c} & {d} & {d} \\\\
+        i & 1.000000 & 2.000000 & 3.000000 \\\\
+        j & 4.000000 & 5.000000 & 6.000000 \\\\
+        j & 7.000000 & 8.000000 & 9.000000 \\\\
+        \\end{tabular}
+    """
+    )
diff --git a/pandas/tests/io/formats/style/test_to_latex.py b/pandas/tests/io/formats/style/test_to_latex.py
new file mode 100644
index 0000000000000..5945502a4c90c
--- /dev/null
+++ b/pandas/tests/io/formats/style/test_to_latex.py
@@ -0,0 +1,440 @@
+from textwrap import dedent
+
+import pytest
+
+from pandas import (
+    DataFrame,
+    MultiIndex,
+    option_context,
+)
+
+pytest.importorskip("jinja2")
+from pandas.io.formats.style import Styler
+from pandas.io.formats.style_render import (
+    _parse_latex_cell_styles,
+    _parse_latex_header_span,
+    _parse_latex_table_styles,
+    _parse_latex_table_wrapping,
+)
+
+
+@pytest.fixture
+def df():
+    return DataFrame({"A": [0, 1], "B": [-0.61, -1.22], "C": ["ab", "cd"]})
+
+
+@pytest.fixture
+def styler(df):
+    return Styler(df, uuid_len=0, precision=2)
+
+
+def test_minimal_latex_tabular(styler):
+    expected = dedent(
+        """\
+        \\begin{tabular}{lrrl}
+        {} & {A} & {B} & {C} \\\\
+        0 & 0 & -0.61 & ab \\\\
+        1 & 1 & -1.22 & cd \\\\
+        \\end{tabular}
+        """
+    )
+    assert styler.to_latex() == expected
+
+
+def test_tabular_hrules(styler):
+    expected = dedent(
+        """\
+        \\begin{tabular}{lrrl}
+        \\toprule
+        {} & {A} & {B} & {C} \\\\
+        \\midrule
+        0 & 0 & -0.61 & ab \\\\
+        1 & 1 & -1.22 & cd \\\\
+        \\bottomrule
+        \\end{tabular}
+        """
+    )
+    assert styler.to_latex(hrules=True) == expected
+
+
+def test_tabular_custom_hrules(styler):
+    styler.set_table_styles(
+        [
+            {"selector": "toprule", "props": ":hline"},
+            {"selector": "bottomrule", "props": ":otherline"},
+        ]
+    )  # no midrule
+    expected = dedent(
+        """\
+        \\begin{tabular}{lrrl}
+        \\hline
+        {} & {A} & {B} & {C} \\\\
+        0 & 0 & -0.61 & ab \\\\
+        1 & 1 & -1.22 & cd \\\\
+        \\otherline
+        \\end{tabular}
+        """
+    )
+    assert styler.to_latex() == expected
+
+
+def test_column_format(styler):
+    # default setting is already tested in `test_latex_minimal_tabular`
+    styler.set_table_styles([{"selector": "column_format", "props": ":cccc"}])
+
+    assert "\\begin{tabular}{rrrr}" in styler.to_latex(column_format="rrrr")
+    styler.set_table_styles([{"selector": "column_format", "props": ":r|r|cc"}])
+    assert "\\begin{tabular}{r|r|cc}" in styler.to_latex()
+
+
+def test_siunitx_cols(styler):
+    expected = dedent(
+        """\
+        \\begin{tabular}{lSSl}
+        {} & {A} & {B} & {C} \\\\
+        0 & 0 & -0.61 & ab \\\\
+        1 & 1 & -1.22 & cd \\\\
+        \\end{tabular}
+        """
+    )
+    assert styler.to_latex(siunitx=True) == expected
+
+
+def test_position(styler):
+    assert "\\begin{table}[h!]" in styler.to_latex(position="h!")
+    assert "\\end{table}" in styler.to_latex(position="h!")
+    styler.set_table_styles([{"selector": "position", "props": ":b!"}])
+    assert "\\begin{table}[b!]" in styler.to_latex()
+    assert "\\end{table}" in styler.to_latex()
+
+
+def test_label(styler):
+    assert "\\label{text}" in styler.to_latex(label="text")
+    styler.set_table_styles([{"selector": "label", "props": ":{more §text}"}])
+    assert "\\label{more :text}" in styler.to_latex()
+
+
+def test_position_float_raises(styler):
+    msg = "`position_float` should be one of 'raggedright', 'raggedleft', 'centering',"
+    with pytest.raises(ValueError, match=msg):
+        styler.to_latex(position_float="bad_string")
+
+
+@pytest.mark.parametrize("label", [(None, ""), ("text", "\\label{text}")])
+@pytest.mark.parametrize("position", [(None, ""), ("h!", "{table}[h!]")])
+@pytest.mark.parametrize("caption", [(None, ""), ("text", "\\caption{text}")])
+@pytest.mark.parametrize("column_format", [(None, ""), ("rcrl", "{tabular}{rcrl}")])
+@pytest.mark.parametrize("position_float", [(None, ""), ("centering", "\\centering")])
+def test_kwargs_combinations(
+    styler, label, position, caption, column_format, position_float
+):
+    result = styler.to_latex(
+        label=label[0],
+        position=position[0],
+        caption=caption[0],
+        column_format=column_format[0],
+        position_float=position_float[0],
+    )
+    assert label[1] in result
+    assert position[1] in result
+    assert caption[1] in result
+    assert column_format[1] in result
+    assert position_float[1] in result
+
+
+def test_custom_table_styles(styler):
+    styler.set_table_styles(
+        [
+            {"selector": "mycommand", "props": ":{myoptions}"},
+            {"selector": "mycommand2", "props": ":{myoptions2}"},
+        ]
+    )
+    expected = dedent(
+        """\
+        \\begin{table}
+        \\mycommand{myoptions}
+        \\mycommand2{myoptions2}
+        """
+    )
+    assert expected in styler.to_latex()
+
+
+def test_cell_styling(styler):
+    styler.highlight_max(props="itshape:;Huge:--wrap;")
+    expected = dedent(
+        """\
+        \\begin{tabular}{lrrl}
+        {} & {A} & {B} & {C} \\\\
+        0 & 0 & \\itshape {\\Huge -0.61} & ab \\\\
+        1 & \\itshape {\\Huge 1} & -1.22 & \\itshape {\\Huge cd} \\\\
+        \\end{tabular}
+        """
+    )
+    assert expected == styler.to_latex()
+
+
+def test_multiindex_columns(df):
+    cidx = MultiIndex.from_tuples([("A", "a"), ("A", "b"), ("B", "c")])
+    df.columns = cidx
+    expected = dedent(
+        """\
+        \\begin{tabular}{lrrl}
+        {} & \\multicolumn{2}{r}{A} & {B} \\\\
+        {} & {a} & {b} & {c} \\\\
+        0 & 0 & -0.61 & ab \\\\
+        1 & 1 & -1.22 & cd \\\\
+        \\end{tabular}
+        """
+    )
+    s = df.style.format(precision=2)
+    assert expected == s.to_latex()
+
+    # non-sparse
+    expected = dedent(
+        """\
+        \\begin{tabular}{lrrl}
+        {} & {A} & {A} & {B} \\\\
+        {} & {a} & {b} & {c} \\\\
+        0 & 0 & -0.61 & ab \\\\
+        1 & 1 & -1.22 & cd \\\\
+        \\end{tabular}
+        """
+    )
+    s = df.style.format(precision=2)
+    assert expected == s.to_latex(sparse_columns=False)
+
+
+def test_multiindex_row(df):
+    ridx = MultiIndex.from_tuples([("A", "a"), ("A", "b"), ("B", "c")])
+    df.loc[2, :] = [2, -2.22, "de"]
+    df = df.astype({"A": int})
+    df.index = ridx
+    expected = dedent(
+        """\
+        \\begin{tabular}{llrrl}
+        {} & {} & {A} & {B} & {C} \\\\
+        \\multirow[c]{2}{*}{A} & a & 0 & -0.61 & ab \\\\
+         & b & 1 & -1.22 & cd \\\\
+        B & c & 2 & -2.22 & de \\\\
+        \\end{tabular}
+        """
+    )
+    s = df.style.format(precision=2)
+    assert expected == s.to_latex()
+
+    # non-sparse
+    expected = dedent(
+        """\
+        \\begin{tabular}{llrrl}
+        {} & {} & {A} & {B} & {C} \\\\
+        A & a & 0 & -0.61 & ab \\\\
+        A & b & 1 & -1.22 & cd \\\\
+        B & c & 2 & -2.22 & de \\\\
+        \\end{tabular}
+        """
+    )
+    assert expected == s.to_latex(sparse_index=False)
+
+
+def test_multiindex_row_and_col(df):
+    cidx = MultiIndex.from_tuples([("Z", "a"), ("Z", "b"), ("Y", "c")])
+    ridx = MultiIndex.from_tuples([("A", "a"), ("A", "b"), ("B", "c")])
+    df.loc[2, :] = [2, -2.22, "de"]
+    df = df.astype({"A": int})
+    df.index, df.columns = ridx, cidx
+    expected = dedent(
+        """\
+        \\begin{tabular}{llrrl}
+        {} & {} & \\multicolumn{2}{l}{Z} & {Y} \\\\
+        {} & {} & {a} & {b} & {c} \\\\
+        \\multirow[b]{2}{*}{A} & a & 0 & -0.61 & ab \\\\
+         & b & 1 & -1.22 & cd \\\\
+        B & c & 2 & -2.22 & de \\\\
+        \\end{tabular}
+        """
+    )
+    s = df.style.format(precision=2)
+    assert s.to_latex(multirow_align="b", multicol_align="l") == expected
+
+    # non-sparse
+    expected = dedent(
+        """\
+        \\begin{tabular}{llrrl}
+        {} & {} & {Z} & {Z} & {Y} \\\\
+        {} & {} & {a} & {b} & {c} \\\\
+        A & a & 0 & -0.61 & ab \\\\
+        A & b & 1 & -1.22 & cd \\\\
+        B & c & 2 & -2.22 & de \\\\
+        \\end{tabular}
+        """
+    )
+    assert s.to_latex(sparse_index=False, sparse_columns=False) == expected
+
+
+def test_multiindex_columns_hidden():
+    df = DataFrame([[1, 2, 3, 4]])
+    df.columns = MultiIndex.from_tuples([("A", 1), ("A", 2), ("A", 3), ("B", 1)])
+    s = df.style
+    assert "{tabular}{lrrrr}" in s.to_latex()
+    s.set_table_styles([])  # reset the position command
+    s.hide_columns([("A", 2)])
+    assert "{tabular}{lrrr}" in s.to_latex()
+
+
+def test_sparse_options(df):
+    cidx = MultiIndex.from_tuples([("Z", "a"), ("Z", "b"), ("Y", "c")])
+    ridx = MultiIndex.from_tuples([("A", "a"), ("A", "b"), ("B", "c")])
+    df.loc[2, :] = [2, -2.22, "de"]
+    df.index, df.columns = ridx, cidx
+    s = df.style
+
+    latex1 = s.to_latex()
+
+    with option_context("styler.sparse.index", True):
+        latex2 = s.to_latex()
+    assert latex1 == latex2
+
+    with option_context("styler.sparse.index", False):
+        latex2 = s.to_latex()
+    assert latex1 != latex2
+
+    with option_context("styler.sparse.columns", True):
+        latex2 = s.to_latex()
+    assert latex1 == latex2
+
+    with option_context("styler.sparse.columns", False):
+        latex2 = s.to_latex()
+    assert latex1 != latex2
+
+
+def test_hidden_index(styler):
+    styler.hide_index()
+    expected = dedent(
+        """\
+        \\begin{tabular}{rrl}
+        {A} & {B} & {C} \\\\
+        0 & -0.61 & ab \\\\
+        1 & -1.22 & cd \\\\
+        \\end{tabular}
+        """
+    )
+    assert styler.to_latex() == expected
+
+
+def test_comprehensive(df):
+    # test as many low level features simultaneously as possible
+    cidx = MultiIndex.from_tuples([("Z", "a"), ("Z", "b"), ("Y", "c")])
+    ridx = MultiIndex.from_tuples([("A", "a"), ("A", "b"), ("B", "c")])
+    df.loc[2, :] = [2, -2.22, "de"]
+    df = df.astype({"A": int})
+    df.index, df.columns = ridx, cidx
+    s = df.style
+    s.set_caption("mycap")
+    s.set_table_styles(
+        [
+            {"selector": "label", "props": ":{fig§item}"},
+            {"selector": "position", "props": ":h!"},
+            {"selector": "position_float", "props": ":centering"},
+            {"selector": "column_format", "props": ":rlrlr"},
+            {"selector": "toprule", "props": ":toprule"},
+            {"selector": "midrule", "props": ":midrule"},
+            {"selector": "bottomrule", "props": ":bottomrule"},
+            {"selector": "rowcolors", "props": ":{3}{pink}{}"},  # custom command
+        ]
+    )
+    s.highlight_max(axis=0, props="textbf:--rwrap;cellcolor:[rgb]{1,1,0.6}--rwrap")
+    s.highlight_max(axis=None, props="Huge:--wrap;", subset=[("Z", "a"), ("Z", "b")])
+
+    expected = (
+        """\
+\\begin{table}[h!]
+\\centering
+\\caption{mycap}
+\\label{fig:item}
+\\rowcolors{3}{pink}{}
+\\begin{tabular}{rlrlr}
+\\toprule
+{} & {} & \\multicolumn{2}{r}{Z} & {Y} \\\\
+{} & {} & {a} & {b} & {c} \\\\
+\\midrule
+\\multirow[c]{2}{*}{A} & a & 0 & \\textbf{\\cellcolor[rgb]{1,1,0.6}{-0.61}} & ab \\\\
+ & b & 1 & -1.22 & cd \\\\
+B & c & \\textbf{\\cellcolor[rgb]{1,1,0.6}{{\\Huge 2}}} & -2.22 & """
+        """\
+\\textbf{\\cellcolor[rgb]{1,1,0.6}{de}} \\\\
+\\bottomrule
+\\end{tabular}
+\\end{table}
+"""
+    )
+    assert s.format(precision=2).to_latex() == expected
+
+
+def test_parse_latex_table_styles(styler):
+    styler.set_table_styles(
+        [
+            {"selector": "foo", "props": [("attr", "value")]},
+            {"selector": "bar", "props": [("attr", "overwritten")]},
+            {"selector": "bar", "props": [("attr", "baz"), ("attr2", "ignored")]},
+            {"selector": "label", "props": [("", "{fig§item}")]},
+        ]
+    )
+    assert _parse_latex_table_styles(styler.table_styles, "bar") == "baz"
+
+    # test '§' replaced by ':' [for CSS compatibility]
+    assert _parse_latex_table_styles(styler.table_styles, "label") == "{fig:item}"
+
+
+def test_parse_latex_cell_styles_basic():  # test nesting
+    cell_style = [("itshape", "--rwrap"), ("cellcolor", "[rgb]{0,1,1}--rwrap")]
+    expected = "\\itshape{\\cellcolor[rgb]{0,1,1}{text}}"
+    assert _parse_latex_cell_styles(cell_style, "text") == expected
+
+
+@pytest.mark.parametrize(
+    "wrap_arg, expected",
+    [  # test wrapping
+        ("", "\\<command><options> <display_value>"),
+        ("--wrap", "{\\<command><options> <display_value>}"),
+        ("--nowrap", "\\<command><options> <display_value>"),
+        ("--lwrap", "{\\<command><options>} <display_value>"),
+        ("--dwrap", "{\\<command><options>}{<display_value>}"),
+        ("--rwrap", "\\<command><options>{<display_value>}"),
+    ],
+)
+def test_parse_latex_cell_styles_braces(wrap_arg, expected):
+    cell_style = [("<command>", f"<options>{wrap_arg}")]
+    assert _parse_latex_cell_styles(cell_style, "<display_value>") == expected
+
+
+def test_parse_latex_header_span():
+    cell = {"attributes": 'colspan="3"', "display_value": "text"}
+    expected = "\\multicolumn{3}{Y}{text}"
+    assert _parse_latex_header_span(cell, "X", "Y") == expected
+
+    cell = {"attributes": 'rowspan="5"', "display_value": "text"}
+    expected = "\\multirow[X]{5}{*}{text}"
+    assert _parse_latex_header_span(cell, "X", "Y") == expected
+
+    cell = {"display_value": "text"}
+    assert _parse_latex_header_span(cell, "X", "Y") == "text"
+
+
+def test_parse_latex_table_wrapping(styler):
+    styler.set_table_styles(
+        [
+            {"selector": "toprule", "props": ":value"},
+            {"selector": "bottomrule", "props": ":value"},
+            {"selector": "midrule", "props": ":value"},
+            {"selector": "column_format", "props": ":value"},
+        ]
+    )
+    assert _parse_latex_table_wrapping(styler.table_styles, styler.caption) is False
+    assert _parse_latex_table_wrapping(styler.table_styles, "some caption") is True
+    styler.set_table_styles(
+        [
+            {"selector": "not-ignored", "props": ":value"},
+        ],
+        overwrite=False,
+    )
+    assert _parse_latex_table_wrapping(styler.table_styles, None) is True