diff --git a/.idea/misc.xml b/.idea/misc.xml
index 39a6ea0..b60b203 100644
--- a/.idea/misc.xml
+++ b/.idea/misc.xml
@@ -1,6 +1,7 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <project version="4">
   <component name="Black">
+    <option name="enabledOnReformat" value="true" />
     <option name="enabledOnSave" value="true" />
     <option name="pathToExecutable" value="/usr/bin/black" />
     <option name="sdkName" value="Python 3.12 (venv12)" />
diff --git a/.idea/plotly-gtk.iml b/.idea/plotly-gtk.iml
index 75d7046..6c1b1b9 100644
--- a/.idea/plotly-gtk.iml
+++ b/.idea/plotly-gtk.iml
@@ -3,6 +3,7 @@
   <component name="NewModuleRootManager">
     <content url="file://$MODULE_DIR$">
       <sourceFolder url="file://$MODULE_DIR$/src" isTestSource="false" />
+      <sourceFolder url="file://$MODULE_DIR$/test" isTestSource="true" />
     </content>
     <orderEntry type="jdk" jdkName="Python 3.12 (venv12)" jdkType="Python SDK" />
     <orderEntry type="sourceFolder" forTests="false" />
diff --git a/.idea/watcherTasks.xml b/.idea/watcherTasks.xml
index b695059..e3e2f4d 100644
--- a/.idea/watcherTasks.xml
+++ b/.idea/watcherTasks.xml
@@ -3,7 +3,6 @@
   <component name="ProjectTasksOptions">
     <enabled-global>
       <option value="isort" />
-      <option value="mypy" />
       <option value="docformatter" />
     </enabled-global>
   </component>
diff --git a/src/plotly_gtk/__init__.py b/src/plotly_gtk/__init__.py
index e69de29..02347bf 100644
--- a/src/plotly_gtk/__init__.py
+++ b/src/plotly_gtk/__init__.py
@@ -0,0 +1,3 @@
+import logging
+
+logging.basicConfig()
diff --git a/src/plotly_gtk/_chart.py b/src/plotly_gtk/_chart.py
index 9f89fe0..6f1d844 100644
--- a/src/plotly_gtk/_chart.py
+++ b/src/plotly_gtk/_chart.py
@@ -85,16 +85,15 @@ def _draw_gridlines(self, context, width, height, axis):
         if "_range" not in self.layout[axis]:
             return
         if axis.startswith("x"):
-            self.layout[axis]["_ticksobject"].update_length(
-                (width - self.layout["_margin"]["l"] - self.layout["_margin"]["r"])
-                * (self.layout[axis]["domain"][-1] - self.layout[axis]["domain"][0])
-            )
+            self.layout[axis]["_ticksobject"].length = (
+                width - self.layout["_margin"]["l"] - self.layout["_margin"]["r"]
+            ) * (self.layout[axis]["domain"][-1] - self.layout[axis]["domain"][0])
+
             self.layout[axis]["_ticksobject"].calculate()
         else:
-            self.layout[axis]["_ticksobject"].update_length(
-                (height - self.layout["_margin"]["t"] - self.layout["_margin"]["b"])
-                * (self.layout[axis]["domain"][-1] - self.layout[axis]["domain"][0])
-            )
+            self.layout[axis]["_ticksobject"].length = (
+                height - self.layout["_margin"]["t"] - self.layout["_margin"]["b"]
+            ) * (self.layout[axis]["domain"][-1] - self.layout[axis]["domain"][0])
             self.layout[axis]["_ticksobject"].calculate()
         if "anchor" in self.layout[axis] and self.layout[axis]["anchor"] != "free":
             anchor = (
@@ -180,7 +179,9 @@ def _draw_ticks(
                     + self.layout[axis]["anchor"][1:]
                 )
                 y = self.layout[yaxis]["_range"][0]
-                x_pos, y_pos = self._calc_pos(x, y, width, height, axis, yaxis)
+                x_pos, y_pos = self._calc_pos(
+                    x, y, width, height, axis, yaxis, ignore_log_y=True
+                )
             else:
                 y_pos = self.layout["_margin"]["t"] + (
                     1 - self.layout[axis]["position"]
@@ -189,7 +190,7 @@ def _draw_ticks(
 
             for tick, text in zip(x_pos, ticktext):
                 context.move_to(tick, y_pos)
-                layout.set_text(text)
+                layout.set_markup(text)
                 layout_size = layout.get_pixel_size()
                 context.rel_move_to(-layout_size[0] / 2, 0)
                 PangoCairo.show_layout(context, layout)
@@ -203,7 +204,9 @@ def _draw_ticks(
                     + self.layout[axis]["anchor"][1:]
                 )
                 x = self.layout[xaxis]["_range"][0]
-                x_pos, y_pos = self._calc_pos(x, y, width, height, xaxis, axis)
+                x_pos, y_pos = self._calc_pos(
+                    x, y, width, height, xaxis, axis, ignore_log_x=True
+                )
             else:
                 x_pos = self.layout["_margin"]["l"] + self.layout[axis]["position"] * (
                     width - self.layout["_margin"]["l"] - self.layout["_margin"]["r"]
@@ -212,7 +215,7 @@ def _draw_ticks(
 
             for tick, text in zip(y_pos, ticktext):
                 context.move_to(x_pos, tick)
-                layout.set_text(text)
+                layout.set_markup(text)
                 layout_size = layout.get_pixel_size()
                 context.rel_move_to(-layout_size[0], -layout_size[1] / 2)
                 PangoCairo.show_layout(context, layout)
diff --git a/src/plotly_gtk/chart.py b/src/plotly_gtk/chart.py
index ebc761d..a50c20c 100644
--- a/src/plotly_gtk/chart.py
+++ b/src/plotly_gtk/chart.py
@@ -87,7 +87,7 @@ def _update_ranges(self):
         for axis in axes:
             if "autorange" in self.layout[axis]:
                 autorange = self.layout[axis]["autorange"]
-            elif "range" in self.layout[axis] and len(self.layout[axis]["range"] == 2):
+            if "range" in self.layout[axis] and len(self.layout[axis]["range"]) == 2:
                 autorange = False
             else:
                 autorange = True
@@ -132,6 +132,16 @@ def _update_ranges(self):
                     _range[0] = _range[0] - 1
                     _range[-1] = _range[1] + 1
                 self.layout[axis]["_range"] = _range
+            else:
+                if self.layout[axis]["type"] == "log":
+                    self.layout[axis]["_range"] = np.array(
+                        [
+                            10 ** self.layout[axis]["range"][0],
+                            10 ** self.layout[axis]["range"][-1],
+                        ]
+                    )
+                else:
+                    self.layout[axis]["_range"] = np.array(self.layout[axis]["range"])
 
         # Do matching
         matched_to_axes = {
@@ -159,11 +169,31 @@ def _update_ranges(self):
                 continue
             if self.layout[axis]["_type"] == "log":
                 self.layout[axis]["_range"] = np.log10(self.layout[axis]["_range"])
+                range_length = (
+                    self.layout[axis]["_range"][-1] - self.layout[axis]["_range"][0]
+                )
+                if (
+                    "range" in self.layout[axis]
+                    and len(self.layout[axis]["range"]) == 2
+                ):
+                    range_addon = range_length * 0.001
+                else:
+                    range_addon = range_length * 0.125 / 2
+                self.layout[axis]["_range"] = [
+                    self.layout[axis]["_range"][0] - range_addon,
+                    self.layout[axis]["_range"][-1] + range_addon,
+                ]
             else:
                 range_length = (
                     self.layout[axis]["_range"][-1] - self.layout[axis]["_range"][0]
                 )
-                range_addon = range_length * 0.125 / 2
+                if (
+                    "range" in self.layout[axis]
+                    and len(self.layout[axis]["range"]) == 2
+                ):
+                    range_addon = range_length * 0.001
+                else:
+                    range_addon = range_length * 0.125 / 2
                 self.layout[axis]["_range"] = [
                     self.layout[axis]["_range"][0] - range_addon,
                     self.layout[axis]["_range"][-1] + range_addon,
diff --git a/src/plotly_gtk/demo.py b/src/plotly_gtk/demo.py
index da804f2..2ac4856 100644
--- a/src/plotly_gtk/demo.py
+++ b/src/plotly_gtk/demo.py
@@ -18,7 +18,7 @@
     "line_1",
     "line_2",
 ]
-log_demos = ["log_1"]
+log_demos = ["log_1", "log_2"]
 
 demos = {"Scatter": scatter_demos, "log": log_demos}
 
@@ -36,6 +36,17 @@ def _get_log_test_figure(reference):
         fig = px.scatter(
             df, x="gdpPercap", y="lifeExp", hover_name="country", log_x=True
         )
+    elif reference == "log_2":
+        df = px.data.gapminder().query("year == 2007")
+        fig = px.scatter(
+            df,
+            x="gdpPercap",
+            y="lifeExp",
+            hover_name="country",
+            log_x=True,
+            range_x=[1, 100000],
+            range_y=[0, 100],
+        )
     return fig
 
 
@@ -79,7 +90,7 @@ def test(app):
     paned = Gtk.Paned()
     window.set_content(paned)
 
-    fig = get_test_figure("log_1")
+    fig = get_test_figure("log_2")
     print(fig)
     # print(fig["layout"]["template"])
 
diff --git a/src/plotly_gtk/utils/__init__.py b/src/plotly_gtk/utils/__init__.py
index 2d3f9f2..579e05a 100644
--- a/src/plotly_gtk/utils/__init__.py
+++ b/src/plotly_gtk/utils/__init__.py
@@ -2,6 +2,7 @@
 :class:`plotly_gtk.chart.PlotlyGtk`."""
 
 import collections
+import importlib
 import json
 import typing
 
@@ -22,7 +23,8 @@
 
 
 def update_dict(d: "GenericType", u: "GenericType") -> "GenericType":
-    """Return a copy of :class:`dict` `d` recursively updated with values from :class:`dict` `u`.
+    """Return a copy of :class:`dict` `d` recursively updated with values from
+    :class:`dict` `u`.
 
     Parameters
     ------
@@ -35,7 +37,6 @@ def update_dict(d: "GenericType", u: "GenericType") -> "GenericType":
     -------
     dict
         A copy of `d` updated with values from `u`
-
     """
     d = dict(d)
     for k, v in u.items():
@@ -47,8 +48,7 @@ def update_dict(d: "GenericType", u: "GenericType") -> "GenericType":
 
 
 def parse_color(color: str) -> tuple[float, float, float]:
-    """
-    Return the RGB components of a color provided as a string.
+    """Return the RGB components of a color provided as a string.
 
     Parameters
     ----------
@@ -73,8 +73,8 @@ def parse_color(color: str) -> tuple[float, float, float]:
 def parse_font(
     font: dict[str, str | int], single_family: bool = False
 ) -> Pango.FontDescription:
-    """
-    Parse a dictionary of font parameters and return a :class:`gi.repository.Pango.FontDescription`.
+    """Parse a dictionary of font parameters and return a
+    :class:`gi.repository.Pango.FontDescription`.
 
     Parameters
     ----------
@@ -89,7 +89,6 @@ def parse_font(
     -------
     gi.repository.Pango.FontDescription
         The fields are set as provided in the input :class:`dict`.
-
     """
     font = f"{font["family"]} {font["style"]} {font["variant"]} {font["weight"]} {font["size"]}px"
     font_desc = Pango.FontDescription.from_string(font)
@@ -103,8 +102,7 @@ def parse_font(
 
 
 def get_cartesian_subplots(data: list[dict]) -> list[tuple[str, str]]:
-    """
-    Get the list of cartesian axes pairings with data plotted on them.
+    """Get the list of cartesian axes pairings with data plotted on them.
 
     Parameters
     ----------
@@ -115,7 +113,6 @@ def get_cartesian_subplots(data: list[dict]) -> list[tuple[str, str]]:
     -------
     list[tuple[str, str]]
         A list of tuples of the form ("xaxis([0-9]+)?", "yaxis([0-9]+)?")
-
     """
     return list(
         {
@@ -129,15 +126,14 @@ def get_cartesian_subplots(data: list[dict]) -> list[tuple[str, str]]:
 
 
 def get_base_fig() -> dict:
-    """
-    Avoid importing plotly by creating a base figure dictionary.
+    """Avoid importing plotly by creating a base figure dictionary.
 
     Returns
     -------
     dict
         The dictionary returned by plotly.graph_object.Figure().to_dict()
     """
-    template = "potly"
+    template = "plotly"
     file = (
         importlib.resources.files(anchor="plotly_gtk.utils")
         / "templates"
@@ -152,8 +148,7 @@ def get_base_fig() -> dict:
 
 
 def round_sf(val: float | int, sf: int = 1) -> float:
-    """
-    Round to specified significant figures.
+    """Round to specified significant figures.
 
     Parameters
     ----------
diff --git a/src/plotly_gtk/utils/ticks.py b/src/plotly_gtk/utils/ticks.py
index 59bf431..5f308aa 100644
--- a/src/plotly_gtk/utils/ticks.py
+++ b/src/plotly_gtk/utils/ticks.py
@@ -1,7 +1,10 @@
+import logging
 import numbers
 
 import numpy as np
 
+logger = logging.getLogger(__name__)
+
 
 class Ticks:
     ROUND_SET = {
@@ -11,55 +14,69 @@ class Ticks:
     }
 
     def __init__(self, layout, axis, length):
+        logger.debug(
+            f"Ticks.__init__(layout: {layout}, axis: {axis}, length: {length})"
+        )
         self.layout = layout
         self.axis = axis
         self.axis_layout = self.layout[axis]
-        self.min = self.axis_layout["_range"][0]
-        self.max = self.axis_layout["_range"][-1]
-        self.length = length
-
-    def update_length(self, length):
+        self.axis_layout["_range"][0] = self.axis_layout["_range"][0]
+        self.axis_layout["_range"][-1] = self.axis_layout["_range"][-1]
         self.length = length
 
     def tick_first(self):
+        logger.debug("Calling Ticks.tick_first")
         axrev = self.axis_layout["_range"][-1] < self.axis_layout["_range"][0]
         round_func = np.floor if axrev else np.ceil
+        logger.debug(f"_dtick: {self.axis_layout["_dtick"]}")
         if isinstance(self.axis_layout["_dtick"], numbers.Number):
             tmin = (
                 round_func(
-                    (self.min - self.axis_layout["_tick0"]) / self.axis_layout["_dtick"]
+                    (self.axis_layout["_range"][0] - self.axis_layout["_tick0"])
+                    / self.axis_layout["_dtick"]
                 )
                 * self.axis_layout["_dtick"]
                 + self.axis_layout["_tick0"]
             )
-            return tmin
-        ttype = self.axis_layout["_dtick"][0]
-        dtnum = int(self.axis_layout["_dtick"][1:])
-        if ttype == "M":
-            # TODO: Implement M type ticks
-            raise NotImplementedError("M type ticks not implemented yet")
-        if ttype == "L":
-            return np.log10(
-                round_func(
-                    (
-                        np.power(10, self.axis_layout["_range"][0])
-                        - self.axis_layout["_tick0"]
+        else:
+            ttype = self.axis_layout["_dtick"][0]
+            dtnum = int(self.axis_layout["_dtick"][1:])
+            if ttype == "M":
+                # TODO: Implement M type ticks
+                raise NotImplementedError("M type ticks not implemented yet")
+            elif ttype == "L":
+                tmin = np.log10(
+                    round_func(
+                        (
+                            np.power(10, self.axis_layout["_range"][0])
+                            - self.axis_layout["_tick0"]
+                        )
+                        / dtnum
                     )
-                    / dtnum
+                    * dtnum
+                    + self.axis_layout["_tick0"]
                 )
-                * dtnum
-                + self.axis_layout["_tick0"]
-            )
-        if ttype == "D":
-            # TODO: Finish
-            tickset = self.ROUND_SET["LOG2"] if dtnum == 2 else self.ROUND_SET["LOG1"]
-            frac = self.round_up(self.axis_layout["_range"][0] % 1, tickset, axrev)
-            return np.floor(self.axis_layout["_range"][0]) + np.log(
-                np.round(np.power(10, frac), 1)
-            ) / np.log(10)
-        raise ValueError(f"Unknown dtick: {self.axis_layout['_dtick']}")
+            elif ttype == "D":
+                # TODO: Finish
+                tickset = (
+                    self.ROUND_SET["LOG2"] if dtnum == 2 else self.ROUND_SET["LOG1"]
+                )
+                tickset = self.ROUND_SET[
+                    "LOG2"
+                ]  # FIXME: temp fix - demo log_1 is returning wrong dtnum
+                frac = self.round_up(self.axis_layout["_range"][0] % 1, tickset, axrev)
+                tmin = np.floor(self.axis_layout["_range"][0]) + np.log(
+                    np.round(np.power(10, frac), 1)
+                ) / np.log(10)
+            else:
+                raise ValueError(f"Unknown dtick: {self.axis_layout['_dtick']}")
+        logger.debug(f"Returning {tmin} from Ticks.tick_first")
+        return tmin
 
     def tick_increment(self, x: float, dtick: str, rev: bool) -> float:
+        logger.debug(
+            f"Calling Ticks.tick_increment(x: {x}, dtick: {dtick}, rev: {rev})"
+        )
         sign = -1 if rev else 1
         ttype = dtick[0]
         dtnum = int(dtick[1:])
@@ -67,42 +84,68 @@ def tick_increment(self, x: float, dtick: str, rev: bool) -> float:
 
         if ttype == "M":
             raise NotImplementedError
-
-        if ttype == "L":
+        elif ttype == "L":
             raise NotImplementedError
-
-        if ttype == "D":
+        elif ttype == "D":
             tickset = self.ROUND_SET["LOG2"] if dtnum == 2 else self.ROUND_SET["LOG1"]
+            tickset = self.ROUND_SET[
+                "LOG2"
+            ]  # FIXME: temp fix - demo log_1 is returning wrong dtnum
             x2 = x + sign * 0.01
             frac = self.round_up(x2 % 1, tickset, rev)
-            return np.floor(x2) + np.log(np.round(np.power(10, frac), 1)) / np.log(10)
-
-        raise ValueError(f"Unknown dtick: {self.axis_layout['_dtick']}")
+            inc = np.floor(x2) + np.log(np.round(np.power(10, frac), 1)) / np.log(10)
+        else:
+            raise ValueError(f"Unknown dtick: {self.axis_layout['_dtick']}")
+        logger.debug(f"Returning {inc} from Ticks.tick_increment")
+        return inc
 
     def calculate(self):
-        self.min = self.axis_layout["_range"][0]
-        self.max = self.axis_layout["_range"][-1]
-        rev = self.min >= self.max
+        rev = self.axis_layout["_range"][0] >= self.axis_layout["_range"][-1]
         self.prepare()
 
         if "tickmode" in self.axis_layout and self.axis_layout["tickmode"] == "array":
             return self.array_ticks()
 
         if isinstance(self.axis_layout["_dtick"], numbers.Number):
+            logger.debug("Numeric dtick")
             self.axis_layout["_tickvals"] = np.arange(
                 self.tick_first(),
-                self.max,
+                self.axis_layout["_range"][-1],
                 self.axis_layout["_dtick"],
             )
         else:
+            logger.debug("Text dtick")
             x = self.tick_first()
-            self.axis_layout["_tickvals"] = np.array([x])
-            while x <= self.max if not rev else self.min:
+            _tickvals = np.array([x])
+            logger.debug(f"_range: {self.axis_layout["_range"]}")
+            while True:
                 x = self.tick_increment(x, self.axis_layout["_dtick"], rev)
-                np.append(self.axis_layout["_tickvals"], [x])
-            self.axis_layout["_tickvals"] = np.exp(self.axis_layout["_tickvals"])
-        self.axis_layout["_ticktext"] = np.char.mod("%g", self.axis_layout["_tickvals"])
-        print(self.axis_layout["_tickvals"])
+                if x >= (
+                    self.axis_layout["_range"][-1]
+                    if not rev
+                    else self.axis_layout["_range"][0]
+                ):
+                    break
+                _tickvals = np.append(_tickvals, [x])
+            logger.debug(f"Original _tickvals: {_tickvals}")
+            self.axis_layout["_tickvals"] = np.power(10, _tickvals)
+            logger.debug(f"Corrected _tickvals: {self.axis_layout["_tickvals"]}")
+        if isinstance(self.axis_layout["_dtick"], numbers.Number):
+            self.axis_layout["_ticktext"] = np.char.mod(
+                "%g", self.axis_layout["_tickvals"]
+            )
+        else:
+            _text = []
+            for _tick in self.axis_layout["_tickvals"]:
+                logval = np.log10(_tick)
+                if logval == np.floor(logval):
+                    _text.append(f"{_tick:g}")
+                else:
+                    _text.append(
+                        f"<sup>{_tick / np.power(10, np.floor(logval)):g}</sup>"
+                    )
+            self.axis_layout["_ticktext"] = _text
+
         return self.axis_layout["_tickvals"]
 
     def prepare(self):
@@ -115,7 +158,9 @@ def prepare(self):
                 min_px = 40 if self.axis.startswith("y") else 80
                 nt = round(self.length / min_px)
                 nt = min(10, max(5, nt))
-            self.auto_ticks((self.max - self.min) / nt)
+            self.auto_ticks(
+                (self.axis_layout["_range"][-1] - self.axis_layout["_range"][0]) / nt
+            )
 
     @staticmethod
     def round_up(value, rounding_set, rev=False):
@@ -134,9 +179,9 @@ def get_base(v):
             return np.power(v, np.floor(np.log(rough_dtick) / np.log(10)))
 
         if self.axis_layout["_type"] == "log":
-            print(rough_dtick)
             self.axis_layout["_tick0"] = 0
-            if rough_dtick > 0.7:
+            # FIXME: make this work
+            if False:  # rough_dtick > 0.7:
                 self.axis_layout["_dtick"] = np.ceil(rough_dtick)
             elif (
                 np.abs(self.axis_layout["_range"][-1] - self.axis_layout["_range"][0])
@@ -162,7 +207,6 @@ def get_base(v):
                 )
             else:
                 self.axis_layout["_dtick"] = "D2" if rough_dtick > 0.3 else "D1"
-            print(self.axis_layout)
         else:
             self.axis_layout["_tick0"] = 0
             base = get_base(10)
diff --git a/test/test_ticks.py b/test/test_ticks.py
new file mode 100644
index 0000000..0673bc4
--- /dev/null
+++ b/test/test_ticks.py
@@ -0,0 +1,32 @@
+class TestTicks:
+    def test_tick_first(self):
+
+        assert False
+
+    def test_tick_increment(self):
+
+        assert False
+
+    def test_calculate(self):
+
+        assert False
+
+    def test_prepare(self):
+
+        assert False
+
+    def test_round_up(self):
+
+        assert False
+
+    def test_round_dtick(self):
+
+        assert False
+
+    def test_auto_ticks(self):
+
+        assert False
+
+    def test_array_ticks(self):
+
+        assert False