diff --git a/condax/cli/install.py b/condax/cli/install.py
index 2fa4a54..f36e4a9 100644
--- a/condax/cli/install.py
+++ b/condax/cli/install.py
@@ -1,11 +1,8 @@
 import logging
-from typing import List
+from pathlib import Path
+from typing import Iterable, List
 
-import click
-
-import condax.config as config
-import condax.core as core
-from condax import __version__
+from condax import __version__, consts, core
 
 from . import cli, options
 
@@ -15,7 +12,7 @@
     Install a package with condax.
 
     This will install a package into a new conda environment and link the executable
-    provided by it to `{config.DEFAULT_BIN_DIR}`.
+    provided by it to `{consts.DEFAULT_PATHS.bin_dir}`.
     """
 )
 @options.channels
@@ -26,9 +23,17 @@ def install(
     packages: List[str],
     is_forcing: bool,
     log_level: int,
+    channels: Iterable[str],
+    prefix_dir: Path,
+    bin_dir: Path,
     **_,
 ):
     for pkg in packages:
         core.install_package(
-            pkg, is_forcing=is_forcing, conda_stdout=log_level <= logging.INFO
+            pkg,
+            is_forcing=is_forcing,
+            conda_stdout=log_level <= logging.INFO,
+            channels=channels,
+            location=prefix_dir,
+            bin_dir=bin_dir,
         )
diff --git a/condax/cli/repair.py b/condax/cli/repair.py
index a9f8cbd..eed4b10 100644
--- a/condax/cli/repair.py
+++ b/condax/cli/repair.py
@@ -27,5 +27,5 @@
 def repair(is_migrating, **_):
     if is_migrating:
         migrate.from_old_version()
-    conda.setup_micromamba()
+    conda.install_micromamba()
     core.fix_links()
diff --git a/condax/conda.py b/condax/conda.py
index 162baf3..471c049 100644
--- a/condax/conda.py
+++ b/condax/conda.py
@@ -1,3 +1,4 @@
+from functools import partial
 import io
 import json
 import logging
@@ -15,7 +16,7 @@
 
 from condax.config import C
 from condax.exceptions import CondaxError
-from condax.utils import to_path
+from condax.utils import FullPath
 import condax.utils as utils
 
 
@@ -26,27 +27,27 @@ def _ensure(execs: Iterable[str], installer: Callable[[], Path]) -> Path:
     for exe in execs:
         exe_path = shutil.which(exe)
         if exe_path is not None:
-            return to_path(exe_path)
+            return FullPath(exe_path)
 
     logger.info("No existing conda installation found. Installing the standalone")
     return installer()
 
 
-def ensure_conda() -> Path:
-    return _ensure(("conda", "mamba"), setup_conda)
+def ensure_conda(bin_dir: Path) -> Path:
+    return _ensure(("conda", "mamba"), partial(install_conda, bin_dir))
 
 
-def ensure_micromamba() -> Path:
-    return _ensure(("micromamba",), setup_micromamba)
+def ensure_micromamba(bin_dir: Path) -> Path:
+    return _ensure(("micromamba",), partial(install_micromamba, bin_dir))
 
 
-def setup_conda() -> Path:
+def install_conda(bin_dir: Path) -> Path:
     url = utils.get_conda_url()
     resp = requests.get(url, allow_redirects=True)
     resp.raise_for_status()
-    utils.mkdir(C.bin_dir())
+    utils.mkdir(bin_dir)
     exe_name = "conda.exe" if os.name == "nt" else "conda"
-    target_filename = C.bin_dir() / exe_name
+    target_filename = bin_dir / exe_name
     with open(target_filename, "wb") as fo:
         fo.write(resp.content)
     st = os.stat(target_filename)
@@ -54,8 +55,8 @@ def setup_conda() -> Path:
     return target_filename
 
 
-def setup_micromamba() -> Path:
-    utils.mkdir(C.bin_dir())
+def install_micromamba(bin_dir: Path) -> Path:
+    utils.mkdir(bin_dir)
     exe_name = "micromamba.exe" if os.name == "nt" else "micromamba"
     umamba_exe = C.bin_dir() / exe_name
     _download_extract_micromamba(umamba_exe)
@@ -89,16 +90,20 @@ def _download_extract_micromamba(umamba_dst: Path) -> None:
 #     )
 
 
-def create_conda_environment(spec: str, stdout: bool) -> None:
+def create_conda_environment(
+    prefix: Path, spec: str, stdout: bool, channels: Iterable[str], bin_dir: Path
+) -> None:
     """Create an environment by installing a package.
 
     NOTE: `spec` may contain version specificaitons.
-    """
-    conda_exe = ensure_conda()
-    prefix = conda_env_prefix(spec)
 
-    channels = C.channels()
-    channels_args = [x for c in channels for x in ["--channel", c]]
+    Args:
+        spec: Package spec to install. e.g. "python=3.6", "python>=3.6", "python", etc.
+        stdout: Whether to print stdout.
+        location: Directory in which to create the environment.
+    """
+    conda_exe = ensure_conda(bin_dir)
+    channels_args = (x for c in channels for x in ("--channel", c))
 
     _subprocess_run(
         [
@@ -163,12 +168,12 @@ def uninject_from_conda_env(
     )
 
 
-def remove_conda_env(package: str, stdout: bool) -> None:
+def remove_conda_env(env: Path, stdout: bool) -> None:
     """Remove a conda environment."""
     conda_exe = ensure_conda()
 
     _subprocess_run(
-        [conda_exe, "remove", "--prefix", conda_env_prefix(package), "--all", "--yes"],
+        [conda_exe, "remove", "--prefix", env, "--all", "--yes"],
         suppress_stdout=not stdout,
     )
 
@@ -212,15 +217,9 @@ def update_conda_env(spec: str, update_specs: bool, stdout: bool) -> None:
     _subprocess_run(command, suppress_stdout=not stdout)
 
 
-def has_conda_env(package: str) -> bool:
+def is_conda_env(path: Path) -> bool:
     # TODO: check some properties of a conda environment
-    p = conda_env_prefix(package)
-    return p.exists() and p.is_dir()
-
-
-def conda_env_prefix(spec: str) -> Path:
-    package, _ = utils.split_match_specs(spec)
-    return C.prefix_dir() / package
+    return path.is_dir()
 
 
 def get_package_info(package: str, specific_name=None) -> Tuple[str, str, str]:
@@ -251,16 +250,14 @@ def __init__(self, package: str):
 
 
 def determine_executables_from_env(
-    package: str, injected_package: Optional[str] = None
+    prefix: Path, package: str, injected_package: Optional[str] = None
 ) -> List[Path]:
-    def is_good(p: Union[str, Path]) -> bool:
-        p = to_path(p)
-        return p.parent.name in ("bin", "sbin", "scripts", "Scripts")
+    def is_exe(p: Union[str, Path]) -> bool:
+        return FullPath(p).parent.name in ("bin", "sbin", "scripts", "Scripts")
 
-    env_prefix = conda_env_prefix(package)
     target_name = injected_package if injected_package else package
 
-    conda_meta_dir = env_prefix / "conda-meta"
+    conda_meta_dir = prefix / "conda-meta"
     for file_name in conda_meta_dir.glob(f"{target_name}*.json"):
         with file_name.open() as fo:
             package_info = json.load(fo)
@@ -268,20 +265,18 @@ def is_good(p: Union[str, Path]) -> bool:
                 potential_executables: Set[str] = {
                     fn
                     for fn in package_info["files"]
-                    if (fn.startswith("bin/") and is_good(fn))
-                    or (fn.startswith("sbin/") and is_good(fn))
+                    if (fn.startswith("bin/") and is_exe(fn))
+                    or (fn.startswith("sbin/") and is_exe(fn))
                     # They are Windows style path
-                    or (fn.lower().startswith("scripts") and is_good(fn))
-                    or (fn.lower().startswith("library") and is_good(fn))
+                    or (fn.lower().startswith("scripts") and is_exe(fn))
+                    or (fn.lower().startswith("library") and is_exe(fn))
                 }
                 break
     else:
         raise DeterminePkgFilesError(target_name)
 
     return sorted(
-        env_prefix / fn
-        for fn in potential_executables
-        if utils.is_executable(env_prefix / fn)
+        prefix / fn for fn in potential_executables if utils.is_executable(prefix / fn)
     )
 
 
@@ -297,7 +292,7 @@ def _get_conda_package_dirs() -> List[Path]:
         return []
 
     d = json.loads(res.stdout.decode())
-    return [to_path(p) for p in d["pkgs_dirs"]]
+    return [FullPath(p) for p in d["pkgs_dirs"]]
 
 
 def _get_dependencies(package: str, pkg_dir: Path) -> List[str]:
diff --git a/condax/config.py b/condax/config.py
index 51cd125..83422d8 100644
--- a/condax/config.py
+++ b/condax/config.py
@@ -4,7 +4,7 @@
 from typing import Any, Dict, List, Optional, Union
 from condax.exceptions import CondaxError
 
-from condax.utils import to_path
+from condax.utils import FullPath
 import condax.condarc as condarc
 import yaml
 
@@ -17,7 +17,7 @@
     _localappdata_dir, "condax", "condax", _config_filename
 )
 _default_config = _default_config_windows if os.name == "nt" else _default_config_unix
-DEFAULT_CONFIG = to_path(os.environ.get("CONDAX_CONFIG", _default_config))
+DEFAULT_CONFIG = FullPath(os.environ.get("CONDAX_CONFIG", _default_config))
 
 _xdg_data_home = os.environ.get("XDG_DATA_HOME", "~/.local/share")
 _default_prefix_dir_unix = os.path.join(_xdg_data_home, "condax", "envs")
@@ -25,22 +25,22 @@
 _default_prefix_dir = (
     _default_prefix_dir_win if os.name == "nt" else _default_prefix_dir_unix
 )
-DEFAULT_PREFIX_DIR = to_path(os.environ.get("CONDAX_PREFIX_DIR", _default_prefix_dir))
+DEFAULT_PREFIX_DIR = FullPath(os.environ.get("CONDAX_PREFIX_DIR", _default_prefix_dir))
 
-DEFAULT_BIN_DIR = to_path(os.environ.get("CONDAX_BIN_DIR", "~/.local/bin"))
+DEFAULT_BIN_DIR = FullPath(os.environ.get("CONDAX_BIN_DIR", "~/.local/bin"))
 
 _channels_in_condarc = condarc.load_channels()
 DEFAULT_CHANNELS = (
     os.environ.get("CONDAX_CHANNELS", " ".join(_channels_in_condarc)).strip().split()
 )
 
-CONDA_ENVIRONMENT_FILE = to_path("~/.conda/environments.txt")
+CONDA_ENVIRONMENT_FILE = FullPath("~/.conda/environments.txt")
 
 conda_path = shutil.which("conda")
 MAMBA_ROOT_PREFIX = (
-    to_path(conda_path).parent.parent
+    FullPath(conda_path).parent.parent
     if conda_path is not None
-    else to_path(os.environ.get("MAMBA_ROOT_PREFIX", "~/micromamba"))
+    else FullPath(os.environ.get("MAMBA_ROOT_PREFIX", "~/micromamba"))
 )
 
 
@@ -94,7 +94,7 @@ def set_via_file(config_file: Union[str, Path]):
     Raises:
         BadConfigFileError: If the config file is not valid.
     """
-    config_file = to_path(config_file)
+    config_file = FullPath(config_file)
     try:
         with config_file.open() as f:
             config = yaml.safe_load(f)
@@ -107,20 +107,20 @@ def set_via_file(config_file: Union[str, Path]):
 
     # For compatibility with condax 0.0.5
     if "prefix_path" in config:
-        prefix_dir = to_path(config["prefix_path"])
+        prefix_dir = FullPath(config["prefix_path"])
         C._set("prefix_dir", prefix_dir)
 
     # For compatibility with condax 0.0.5
     if "target_destination" in config:
-        bin_dir = to_path(config["target_destination"])
+        bin_dir = FullPath(config["target_destination"])
         C._set("bin_dir", bin_dir)
 
     if "prefix_dir" in config:
-        prefix_dir = to_path(config["prefix_dir"])
+        prefix_dir = FullPath(config["prefix_dir"])
         C._set("prefix_dir", prefix_dir)
 
     if "bin_dir" in config:
-        bin_dir = to_path(config["bin_dir"])
+        bin_dir = FullPath(config["bin_dir"])
         C._set("bin_dir", bin_dir)
 
     if "channels" in config:
@@ -137,10 +137,10 @@ def set_via_value(
     Set a part of values in the object C by passing values directly.
     """
     if prefix_dir:
-        C._set("prefix_dir", to_path(prefix_dir))
+        C._set("prefix_dir", FullPath(prefix_dir))
 
     if bin_dir:
-        C._set("bin_dir", to_path(bin_dir))
+        C._set("bin_dir", FullPath(bin_dir))
 
     if channels:
         C._set("channels", channels + C.channels())
diff --git a/condax/consts.py b/condax/consts.py
new file mode 100644
index 0000000..390053a
--- /dev/null
+++ b/condax/consts.py
@@ -0,0 +1,54 @@
+from dataclasses import dataclass
+import os
+from pathlib import Path
+
+
+from condax.utils import FullPath
+
+
+IS_WIN = os.name == "nt"
+IS_UNIX = not IS_WIN
+
+
+@dataclass
+class Paths:
+    conf_dir: Path
+    bin_dir: Path
+    data_dir: Path
+    conf_file_name: str = "condax.yml"
+    envs_dir_name: str = "envs"
+
+    @property
+    def conf_file(self) -> Path:
+        return self.conf_dir / self.conf_file_name
+
+    @property
+    def prefix_dir(self) -> Path:
+        return self.data_dir / self.envs_dir_name
+
+
+class _WindowsPaths(Paths):
+    def __init__(self):
+        conf_dir = data_dir = (
+            FullPath(os.environ.get("LOCALAPPDATA", "~/AppData/Local"))
+            / "condax/condax"
+        )
+        super().__init__(
+            conf_dir=conf_dir,
+            bin_dir=conf_dir / "bin",
+            data_dir=data_dir,
+        )
+
+
+class _UnixPaths(Paths):
+    def __init__(self):
+        super().__init__(
+            conf_dir=FullPath(os.environ.get("XDG_CONFIG_HOME", "~/.config"))
+            / "condax",
+            bin_dir=FullPath("~/.local/bin"),
+            data_dir=FullPath(os.environ.get("XDG_DATA_HOME", "~/.local/share"))
+            / "condax",
+        )
+
+
+DEFAULT_PATHS: Paths = _UnixPaths() if IS_UNIX else _WindowsPaths()
diff --git a/condax/core.py b/condax/core.py
index a110e04..5f87dac 100644
--- a/condax/core.py
+++ b/condax/core.py
@@ -20,31 +20,34 @@
 logger = logging.getLogger(__name__)
 
 
-def create_link(package: str, exe: Path, is_forcing: bool = False) -> bool:
-    micromamba_exe = conda.ensure_micromamba()
+def create_link(env: Path, exe: Path, bin_dir: Path, is_forcing: bool = False) -> bool:
+    micromamba_exe = conda.ensure_micromamba(bin_dir)
     executable_name = exe.name
     # FIXME: Enforcing conda (not mamba) for `conda run` for now
-    prefix = conda.conda_env_prefix(package)
     if os.name == "nt":
         script_lines = [
             "@rem Entrypoint created by condax\n",
-            f"@call {utils.quote(micromamba_exe)} run --prefix {utils.quote(prefix)} {utils.quote(exe)} %*\n",
+            f"@call {utils.quote(micromamba_exe)} run --prefix {utils.quote(env)} {utils.quote(exe)} %*\n",
         ]
     else:
         script_lines = [
             "#!/usr/bin/env bash\n",
             "\n",
             "# Entrypoint created by condax\n",
-            f'{utils.quote(micromamba_exe)} run --prefix {utils.quote(prefix)} {utils.quote(exe)} "$@"\n',
+            f'{utils.quote(micromamba_exe)} run --prefix {utils.quote(env)} {utils.quote(exe)} "$@"\n',
         ]
         if utils.to_bool(os.environ.get("CONDAX_HIDE_EXITCODE", False)):
             # Let scripts to return exit code 0 constantly
             script_lines.append("exit 0\n")
 
-    script_path = _get_wrapper_path(executable_name)
+    script_path = _get_wrapper_path(bin_dir / executable_name)
     if script_path.exists() and not is_forcing:
-        user_input = input(f"{executable_name} already exists. Overwrite? (y/N) ")
-        if user_input.strip().lower() not in ("y", "yes"):
+        answer = (
+            input(f"{executable_name} already exists. Overwrite? (y/N) ")
+            .strip()
+            .lower()
+        )
+        if answer not in ("y", "yes"):
             logger.warning(f"Skipped creating entrypoint: {executable_name}")
             return False
 
@@ -58,12 +61,12 @@ def create_link(package: str, exe: Path, is_forcing: bool = False) -> bool:
 
 
 def create_links(
-    package: str, executables_to_link: Iterable[Path], is_forcing: bool = False
+    env: Path, executables_to_link: Iterable[Path], bin_dir, is_forcing: bool = False
 ):
     linked = (
         exe.name
         for exe in sorted(executables_to_link)
-        if create_link(package, exe, is_forcing=is_forcing)
+        if create_link(env, exe, bin_dir, is_forcing=is_forcing)
     )
     if executables_to_link:
         logger.info("\n  - ".join(("Created the following entrypoint links:", *linked)))
@@ -98,32 +101,36 @@ def remove_links(package: str, app_names_to_unlink: Iterable[str]):
 
 
 class PackageInstalledError(CondaxError):
-    def __init__(self, package: str):
+    def __init__(self, package: str, location: Path):
         super().__init__(
             20,
-            f"Package `{package}` is already installed. Use `--force` to force install.",
+            f"Package `{package}` is already installed at {location / package}. Use `--force` to overwrite.",
         )
 
 
 def install_package(
     spec: str,
+    location: Path,
+    bin_dir: Path,
+    channels: Iterable[str],
     is_forcing: bool = False,
     conda_stdout: bool = False,
 ):
     package, _ = utils.split_match_specs(spec)
+    env = location / package
 
-    if conda.has_conda_env(package):
+    if conda.is_conda_env(env):
         if is_forcing:
             logger.warning(f"Overwriting environment for {package}")
-            conda.remove_conda_env(package, conda_stdout)
+            conda.remove_conda_env(env, conda_stdout)
         else:
-            raise PackageInstalledError(package)
+            raise PackageInstalledError(package, location)
 
-    conda.create_conda_environment(spec, conda_stdout)
-    executables_to_link = conda.determine_executables_from_env(package)
-    utils.mkdir(C.bin_dir())
-    create_links(package, executables_to_link, is_forcing=is_forcing)
-    _create_metadata(package)
+    conda.create_conda_environment(env, spec, conda_stdout, channels, bin_dir)
+    executables_to_link = conda.determine_executables_from_env(env, package)
+    utils.mkdir(bin_dir)
+    create_links(env, executables_to_link, bin_dir, is_forcing=is_forcing)
+    _create_metadata(env, package)
     logger.info(f"`{package}` has been installed by condax")
 
 
@@ -372,12 +379,12 @@ def update_package(
         _inject_to_metadata(env, pkg)
 
 
-def _create_metadata(package: str):
+def _create_metadata(env: Path, package: str):
     """
     Create metadata file
     """
-    apps = [p.name for p in conda.determine_executables_from_env(package)]
-    main = metadata.MainPackage(package, apps)
+    apps = [p.name for p in conda.determine_executables_from_env(env, package)]
+    main = metadata.MainPackage(package, env, apps)
     meta = metadata.CondaxMetaData(main)
     meta.save()
 
@@ -486,11 +493,8 @@ def _get_apps(env_name: str) -> List[str]:
     ]
 
 
-def _get_wrapper_path(cmd_name: str) -> Path:
-    p = C.bin_dir() / cmd_name
-    if os.name == "nt":
-        p = p.parent / (p.stem + ".bat")
-    return p
+def _get_wrapper_path(p: Path) -> Path:
+    return p.parent / (p.stem + ".bat") if os.name == "nt" else p
 
 
 def export_all_environments(out_dir: str, conda_stdout: bool = False) -> None:
diff --git a/condax/metadata.py b/condax/metadata.py
index 002b0a8..9cd641d 100644
--- a/condax/metadata.py
+++ b/condax/metadata.py
@@ -1,29 +1,32 @@
+from dataclasses import dataclass
 import json
 from pathlib import Path
-from typing import List, Optional
+from typing import Iterable, List, Optional
 
-from condax.config import C
 
-
-class _PackageBase(object):
+class _PackageBase:
     def __init__(self, name: str, apps: List[str], include_apps: bool):
         self.name = name
         self.apps = apps
         self.include_apps = include_apps
 
+    def __lt__(self, other):
+        return self.name < other.name
+
 
+@dataclass
 class MainPackage(_PackageBase):
-    def __init__(self, name: str, apps: List[str], include_apps: bool = True):
-        self.name = name
-        self.apps = apps
-        self.include_apps = True
+    name: str
+    prefix: Path
+    apps: List[str]
+    include_apps: bool = True
 
 
 class InjectedPackage(_PackageBase):
     pass
 
 
-class CondaxMetaData(object):
+class CondaxMetaData:
     """
     Handle metadata information written in `condax_metadata.json`
     placed in each environment.
@@ -31,37 +34,29 @@ class CondaxMetaData(object):
 
     metadata_file = "condax_metadata.json"
 
-    @classmethod
-    def get_path(cls, package: str) -> Path:
-        p = C.prefix_dir() / package / cls.metadata_file
-        return p
-
-    def __init__(self, main: MainPackage, injected: List[InjectedPackage] = []):
+    def __init__(self, main: MainPackage, injected: Iterable[InjectedPackage] = ()):
         self.main_package = main
-        self.injected_packages = injected
+        self.injected_packages = tuple(sorted(injected))
 
     def inject(self, package: InjectedPackage):
-        if self.injected_packages is None:
-            self.injected_packages = []
-        already_injected = [p.name for p in self.injected_packages]
-        if package.name in already_injected:
-            return
-        self.injected_packages.append(package)
+        self.injected_packages = tuple(sorted(set(self.injected_packages) | {package}))
 
     def uninject(self, name: str):
-        self.injected_packages = [p for p in self.injected_packages if p.name != name]
+        self.injected_packages = tuple(
+            p for p in self.injected_packages if p.name != name
+        )
 
     def to_json(self) -> str:
         return json.dumps(self, default=lambda o: o.__dict__, sort_keys=True, indent=4)
 
     def save(self) -> None:
-        p = CondaxMetaData.get_path(self.main_package.name)
+        p = self.main_package.prefix / self.metadata_file
         with open(p, "w") as fo:
             fo.write(self.to_json())
 
 
-def load(package: str) -> Optional[CondaxMetaData]:
-    p = CondaxMetaData.get_path(package)
+def load(prefix: Path) -> Optional[CondaxMetaData]:
+    p = prefix / CondaxMetaData.metadata_file
     if not p.exists():
         return None
 
diff --git a/condax/utils.py b/condax/utils.py
index de285de..e12e51f 100644
--- a/condax/utils.py
+++ b/condax/utils.py
@@ -8,7 +8,7 @@
 from condax.exceptions import CondaxError
 
 
-pat = re.compile(r"<=|>=|==|!=|<|>|=")
+pat = re.compile(r"(?=<=|>=|==|!=|<|>|=|$)")
 
 
 def split_match_specs(package_with_specs: str) -> Tuple[str, str]:
@@ -36,22 +36,25 @@ def split_match_specs(package_with_specs: str) -> Tuple[str, str]:
     >>> split_match_specs("numpy")
     ("numpy", "")
     """
-    name, *_ = pat.split(package_with_specs)
-    # replace with str.removeprefix() once Python>=3.9 is assured
-    match_specs = package_with_specs[len(name) :]
+    name, match_specs = pat.split(package_with_specs, 1)
     return name.strip(), match_specs.strip()
 
 
-def to_path(path: Union[str, Path]) -> Path:
+def env_name(package_with_specs: str) -> str:
     """
-    Convert a string to a pathlib.Path object.
+    Get the name of a conda environment from its specification.
     """
-    return Path(path).expanduser().resolve()
+    return split_match_specs(package_with_specs)[0]
 
 
-def mkdir(path: Union[Path, str]) -> None:
+class FullPath(Path):
+    def __new__(cls, *args, **kwargs):
+        return super().__new__(Path, Path(*args, **kwargs).expanduser().resolve())
+
+
+def mkdir(path: Path) -> None:
     """mkdir -p path"""
-    to_path(path).mkdir(exist_ok=True, parents=True)
+    path.mkdir(exist_ok=True, parents=True)
 
 
 def quote(path: Union[Path, str]) -> str:
@@ -184,5 +187,5 @@ def to_bool(value: Union[str, bool]) -> bool:
 
 def is_env_dir(path: Union[Path, str]) -> bool:
     """Check if a path is a conda environment directory."""
-    p = to_path(path)
+    p = FullPath(path)
     return (p / "conda-meta" / "history").exists()
diff --git a/condax/wrapper.py b/condax/wrapper.py
index 7677990..693cca6 100644
--- a/condax/wrapper.py
+++ b/condax/wrapper.py
@@ -6,7 +6,7 @@
 from pathlib import Path
 from typing import Optional, List, Union
 
-from condax.utils import to_path
+from condax.utils import FullPath
 
 
 def read_env_name(script_path: Union[str, Path]) -> Optional[str]:
@@ -15,7 +15,7 @@ def read_env_name(script_path: Union[str, Path]) -> Optional[str]:
 
     Returns the environment name within which conda run is executed.
     """
-    path = to_path(script_path)
+    path = FullPath(script_path)
     script_name = path.name
     if not path.exists():
         logging.warning(f"File missing: `{path}`.")
@@ -52,7 +52,7 @@ def is_wrapper(exec_path: Union[str, Path]) -> bool:
     """
     Check if a file is a condax wrapper script.
     """
-    path = to_path(exec_path)
+    path = FullPath(exec_path)
     if not path.exists():
         return False
 
@@ -106,7 +106,7 @@ def _parse_line(cls, line: str) -> Optional[argparse.Namespace]:
             return None
 
         first_word = words[0]
-        cmd = to_path(first_word).stem
+        cmd = FullPath(first_word).stem
         if cmd not in ("conda", "mamba", "micromamba"):
             return None
 
diff --git a/tests/test_condax.py b/tests/test_condax.py
index 081d386..6dad8cb 100644
--- a/tests/test_condax.py
+++ b/tests/test_condax.py
@@ -8,12 +8,12 @@ def test_pipx_install_roundtrip():
     """
     from condax.core import install_package, remove_package
     import condax.config as config
-    from condax.utils import to_path
+    from condax.utils import FullPath
 
     prefix_fp = tempfile.TemporaryDirectory()
-    prefix_dir = to_path(prefix_fp.name)
+    prefix_dir = FullPath(prefix_fp.name)
     bin_fp = tempfile.TemporaryDirectory()
-    bin_dir = to_path(bin_fp.name)
+    bin_dir = FullPath(bin_fp.name)
     channels = ["conda-forge", "default"]
     config.set_via_value(prefix_dir=prefix_dir, bin_dir=bin_dir, channels=channels)
 
@@ -53,12 +53,12 @@ def test_install_specific_version():
     """
     from condax.core import install_package, remove_package
     import condax.config as config
-    from condax.utils import to_path
+    from condax.utils import FullPath
 
     prefix_fp = tempfile.TemporaryDirectory()
-    prefix_dir = to_path(prefix_fp.name)
+    prefix_dir = FullPath(prefix_fp.name)
     bin_fp = tempfile.TemporaryDirectory()
-    bin_dir = to_path(bin_fp.name)
+    bin_dir = FullPath(bin_fp.name)
     channels = ["conda-forge", "default"]
     config.set_via_value(prefix_dir=prefix_dir, bin_dir=bin_dir, channels=channels)
 
@@ -102,12 +102,12 @@ def test_inject_then_uninject():
     """
     from condax.core import install_package, inject_package_to, uninject_package_from
     import condax.config as config
-    from condax.utils import to_path
+    from condax.utils import FullPath
 
     prefix_fp = tempfile.TemporaryDirectory()
-    prefix_dir = to_path(prefix_fp.name)
+    prefix_dir = FullPath(prefix_fp.name)
     bin_fp = tempfile.TemporaryDirectory()
-    bin_dir = to_path(bin_fp.name)
+    bin_dir = FullPath(bin_fp.name)
     channels = ["conda-forge", "default"]
     config.set_via_value(prefix_dir=prefix_dir, bin_dir=bin_dir, channels=channels)
 
@@ -194,13 +194,13 @@ def test_inject_with_include_apps():
         remove_package,
     )
     import condax.config as config
-    from condax.utils import to_path
+    from condax.utils import FullPath
 
     # prep
     prefix_fp = tempfile.TemporaryDirectory()
-    prefix_dir = to_path(prefix_fp.name)
+    prefix_dir = FullPath(prefix_fp.name)
     bin_fp = tempfile.TemporaryDirectory()
-    bin_dir = to_path(bin_fp.name)
+    bin_dir = FullPath(bin_fp.name)
     channels = ["conda-forge", "default"]
     config.set_via_value(prefix_dir=prefix_dir, bin_dir=bin_dir, channels=channels)
 
diff --git a/tests/test_condax_more.py b/tests/test_condax_more.py
index 1f034c6..3725545 100644
--- a/tests/test_condax_more.py
+++ b/tests/test_condax_more.py
@@ -15,18 +15,18 @@ def test_export_import():
         import_environments,
     )
     import condax.config as config
-    from condax.utils import to_path
+    from condax.utils import FullPath
 
     # prep
     prefix_fp = tempfile.TemporaryDirectory()
-    prefix_dir = to_path(prefix_fp.name)
+    prefix_dir = FullPath(prefix_fp.name)
     bin_fp = tempfile.TemporaryDirectory()
-    bin_dir = to_path(bin_fp.name)
+    bin_dir = FullPath(bin_fp.name)
     channels = ["conda-forge"]
     config.set_via_value(prefix_dir=prefix_dir, bin_dir=bin_dir, channels=channels)
 
     export_dir_fp = tempfile.TemporaryDirectory()
-    export_dir = to_path(export_dir_fp.name)
+    export_dir = FullPath(export_dir_fp.name)
 
     gh = "gh"
     injected_rg_name = "ripgrep"
diff --git a/tests/test_condax_repair.py b/tests/test_condax_repair.py
index e6a058e..93dc47c 100644
--- a/tests/test_condax_repair.py
+++ b/tests/test_condax_repair.py
@@ -8,13 +8,13 @@ def test_fix_links():
     """
     from condax.core import install_package, inject_package_to, fix_links
     import condax.config as config
-    from condax.utils import to_path
+    from condax.utils import FullPath
 
     # prep
     prefix_fp = tempfile.TemporaryDirectory()
-    prefix_dir = to_path(prefix_fp.name)
+    prefix_dir = FullPath(prefix_fp.name)
     bin_fp = tempfile.TemporaryDirectory()
-    bin_dir = to_path(bin_fp.name)
+    bin_dir = FullPath(bin_fp.name)
     channels = ["conda-forge"]
     config.set_via_value(prefix_dir=prefix_dir, bin_dir=bin_dir, channels=channels)
 
@@ -107,13 +107,13 @@ def test_fix_links_without_metadata():
     )
     import condax.config as config
     import condax.metadata as metadata
-    from condax.utils import to_path
+    from condax.utils import FullPath
 
     # prep
     prefix_fp = tempfile.TemporaryDirectory()
-    prefix_dir = to_path(prefix_fp.name)
+    prefix_dir = FullPath(prefix_fp.name)
     bin_fp = tempfile.TemporaryDirectory()
-    bin_dir = to_path(bin_fp.name)
+    bin_dir = FullPath(bin_fp.name)
     channels = ["conda-forge"]
     config.set_via_value(prefix_dir=prefix_dir, bin_dir=bin_dir, channels=channels)
 
diff --git a/tests/test_condax_update.py b/tests/test_condax_update.py
index a31f9f9..b1caaf2 100644
--- a/tests/test_condax_update.py
+++ b/tests/test_condax_update.py
@@ -9,14 +9,14 @@ def test_condax_update_main_apps():
         update_package,
     )
     import condax.config as config
-    from condax.utils import to_path, is_env_dir
+    from condax.utils import FullPath, is_env_dir
     import condax.metadata as metadata
 
     # prep
     prefix_fp = tempfile.TemporaryDirectory()
-    prefix_dir = to_path(prefix_fp.name)
+    prefix_dir = FullPath(prefix_fp.name)
     bin_fp = tempfile.TemporaryDirectory()
-    bin_dir = to_path(bin_fp.name)
+    bin_dir = FullPath(bin_fp.name)
     channels = ["conda-forge", "bioconda"]
     config.set_via_value(prefix_dir=prefix_dir, bin_dir=bin_dir, channels=channels)