diff --git a/README.md b/README.md
index f1de8f5..da9ed6a 100644
--- a/README.md
+++ b/README.md
@@ -6,3 +6,5 @@ use as:
 ```
 conan config install https://github.com/Ultimaker/conan-config.git
 ```
+
+
diff --git a/conan.conf b/conan.conf
deleted file mode 100644
index 5d1090d..0000000
--- a/conan.conf
+++ /dev/null
@@ -1,25 +0,0 @@
-[log]
-run_to_output = True        # environment CONAN_LOG_RUN_TO_OUTPUT
-run_to_file = False         # environment CONAN_LOG_RUN_TO_FILE
-level = warn                # environment CONAN_LOGGING_LEVEL
-print_run_commands = True   # environment CONAN_PRINT_RUN_COMMANDS
-
-[general]
-default_profile = default
-compression_level = 9                 # environment CONAN_COMPRESSION_LEVEL
-sysrequires_sudo = True               # environment CONAN_SYSREQUIRES_SUDO
-request_timeout = 60                  # environment CONAN_REQUEST_TIMEOUT (seconds)
-default_package_id_mode = full_package_mode # environment CONAN_DEFAULT_PACKAGE_ID_MODE
-revisions_enabled = True
-scm_to_conandata = True
-use_always_short_paths = True
-config_install_interval = 12h
-skip_broken_symlinks_check = True
-
-[storage]
-path = ./data
-
-[proxies]
-
-[hooks]
-attribute_checker
diff --git a/generators/PyCharmRunEnv.py b/extensions/generators/PyCharmRunEnv.py
similarity index 64%
rename from generators/PyCharmRunEnv.py
rename to extensions/generators/PyCharmRunEnv.py
index 14f5570..3e32a71 100644
--- a/generators/PyCharmRunEnv.py
+++ b/extensions/generators/PyCharmRunEnv.py
@@ -1,12 +1,18 @@
 from pathlib import Path
 from typing import Dict
 
-from conans import tools
-from conans.model import Generator
 from jinja2 import Template
+from conan import ConanFile
+from conan.tools.scm import Version
+from conan.tools.files import save
 from conan.tools.env.virtualrunenv import VirtualRunEnv
 
-class PyCharmRunEnv(Generator):
+
+class PyCharmRunEnv:
+    def __init__(self, conanfile: ConanFile):
+        self.conanfile: ConanFile = conanfile
+        self.settings = self.conanfile.settings
+
     @property
     def _base_dir(self):
         return Path("$PROJECT_DIR$", "venv")
@@ -14,7 +20,8 @@ class PyCharmRunEnv(Generator):
     @property
     def _py_interp(self):
         if self.settings.os == "Windows":
-            py_interp = Path(*[f'"{p}"' if " " in p else p for p in self._base_dir.joinpath("Scripts", "python.exe").parts])
+            py_interp = Path(
+                *[f'"{p}"' if " " in p else p for p in self._base_dir.joinpath("Scripts", "python.exe").parts])
             return py_interp
         return self._base_dir.joinpath("bin", "python")
 
@@ -22,21 +29,13 @@ class PyCharmRunEnv(Generator):
     def _site_packages(self):
         if self.settings.os == "Windows":
             return self._base_dir.joinpath("Lib", "site-packages")
-        py_version = tools.Version(self.conanfile.deps_cpp_info["cpython"].version)
+        py_version = Version(self.conanfile.dependencies["cpython"].ref.version)
         return self._base_dir.joinpath("lib", f"python{py_version.major}.{py_version.minor}", "site-packages")
 
-    @property
-    def filename(self):
-        pass
-
-    @property
-    def content(self) -> Dict[str, str]:
-        # Mapping of file names -> files
-        run_configurations: Dict[str, str] = {}
-
-        if not hasattr(self.conanfile, "_pycharm_targets"):
+    def generate(self) -> None:
+        if self.conanfile.conan_data is None or "pycharm_targets" not in self.conanfile.conan_data:
             # There are no _pycharm_targets in the conanfile for the package using this generator.
-            return run_configurations
+            return
 
         # Collect environment variables for use in the template
         env = VirtualRunEnv(self.conanfile).environment()
@@ -48,15 +47,13 @@ class PyCharmRunEnv(Generator):
                 env.compose_env(project_run_env)  # TODO: Add logic for dependencies
 
         # Create Pycharm run configuration from template for each target
-        for target in self.conanfile._pycharm_targets:
+        for target in self.conanfile.conan_data["pycharm_targets"]:
             target["env_vars"] = env.vars(self.conanfile, scope="run")
             target["sdk_path"] = str(self._py_interp)
             if "parameters" not in target:
                 target["parameters"] = ""
 
-            with open(target["jinja_path"], "r") as f:
+            with open(Path(self.conanfile.source_folder, target["jinja_path"]), "r") as f:
                 template = Template(f.read())
                 run_configuration = template.render(target)
-                run_configurations[str(Path(self.conanfile.source_folder).joinpath(".run", f"{target['name']}.run.xml"))] = run_configuration
-
-        return run_configurations
+                save(self.conanfile, Path(".run", f"{target['name']}.run.xml"), run_configuration)
diff --git a/extensions/generators/VirtualPythonEnv.py b/extensions/generators/VirtualPythonEnv.py
new file mode 100644
index 0000000..612f8b9
--- /dev/null
+++ b/extensions/generators/VirtualPythonEnv.py
@@ -0,0 +1,160 @@
+import os
+import sys
+from io import StringIO
+from shutil import which
+from pathlib import Path
+
+from conan import ConanFile
+from conan.errors import ConanException
+from conan.tools.files import copy, save, load
+from conan.tools.scm import Version
+from conan.tools.env import VirtualRunEnv
+import subprocess
+
+
+class VirtualPythonEnv:
+    def __init__(self, conanfile: ConanFile):
+        self.conanfile: ConanFile = conanfile
+
+    def generate(self) -> None:
+        '''
+        Creates a Python venv using the CPython installed by conan, then create a script so that this venv can be easily used
+        in Conan commands, and finally install the pip dependencies declared in the conanfile data
+        '''
+        venv_name = f"{self.conanfile.name}_venv"
+        bin_venv_path = "Scripts" if self.conanfile.settings.os == "Windows" else "bin"
+
+        # Check if CPython is added as a dependency use the Conan recipe if available; if not use system interpreter
+        try:
+            cpython = self.conanfile.dependencies["cpython"]
+            py_interp = cpython.conf_info.get("user.cpython:python").replace("\\", "/")
+        except KeyError:
+            py_interp = sys.executable
+
+        run_env = VirtualRunEnv(self.conanfile)
+        env = run_env.environment()
+        env_vars = env.vars(self.conanfile, scope="run")
+
+        venv_folder = os.path.abspath(venv_name)
+
+        self.conanfile.output.info(f"Using Python interpreter '{py_interp}' to create Virtual Environment in '{venv_folder}'")
+        with env_vars.apply():
+            subprocess.run([py_interp, "-m", "venv", "--copies", venv_folder], check=True)
+
+        # Make sure there executable is named the same on all three OSes this allows it to be called with `python`
+        # simplifying GH Actions steps
+        if self.conanfile.settings.os != "Windows":
+            py_interp_venv = Path(venv_folder, bin_venv_path, "python")
+            if not py_interp_venv.exists():
+                py_interp_venv.hardlink_to(
+                    Path(venv_folder, bin_venv_path, Path(sys.executable).stem + Path(sys.executable).suffix))
+        else:
+            py_interp_venv = Path(venv_folder, bin_venv_path,
+                                Path(sys.executable).stem + Path(sys.executable).suffix)
+
+        # Generate a script that mimics the venv activate script but is callable easily in Conan commands
+        with env_vars.apply():
+            buffer = subprocess.run([py_interp_venv, "-c", "import sysconfig; print(sysconfig.get_path('purelib'))"], capture_output=True, encoding="utf-8", check=True).stdout
+        pythonpath = buffer.splitlines()[-1]
+
+        env.define_path("VIRTUAL_ENV", venv_folder)
+        env.prepend_path("PATH", os.path.join(venv_folder, bin_venv_path))
+        env.prepend_path("LD_LIBRARY_PATH", os.path.join(venv_folder, bin_venv_path))
+        env.prepend_path("DYLD_LIBRARY_PATH", os.path.join(venv_folder, bin_venv_path))
+        env.prepend_path("PYTHONPATH", pythonpath)
+        env.unset("PYTHONHOME")
+        env_vars.save_script("virtual_python_env")
+
+        # Install some base packages
+        with env_vars.apply():
+            subprocess.run([py_interp_venv, "-m", "pip", "install", "--upgrade", "pip"], check=True)
+            subprocess.run([py_interp_venv, "-m", "pip", "install", "wheel", "setuptools"], check=True)
+
+        requirements_core = self._make_pip_requirements_files("core")
+        requirements_dev = self._make_pip_requirements_files("dev")
+        requirements_installer = self._make_pip_requirements_files("installer")
+
+        self._install_pip_requirements(requirements_core, env_vars, py_interp_venv)
+
+        if self.conanfile.conf.get("user.generator.virtual_python_env:dev_tools", default=False, check_type=bool):
+            self._install_pip_requirements(requirements_dev, env_vars, py_interp_venv)
+
+        if self.conanfile.conf.get("user.generator.virtual_python_env:installer_tools", default=False,
+                                       check_type=bool):
+            self._install_pip_requirements(requirements_installer, env_vars, py_interp_venv)
+
+    def _install_pip_requirements(self, files_paths, env_vars, py_interp_venv):
+        with env_vars.apply():
+            for file_path in files_paths:
+                self.conanfile.output.info(f"Installing pip requirements from {file_path}")
+                subprocess.run([py_interp_venv, "-m", "pip", "install", "-r", file_path], check=True)
+
+
+    def _make_pip_requirements_files(self, suffix):
+        actual_os = str(self.conanfile.settings.os)
+
+        pip_requirements = VirtualPythonEnv._populate_pip_requirements(self.conanfile, suffix, actual_os)
+
+        for _, dependency in reversed(self.conanfile.dependencies.host.items()):
+            pip_requirements |= VirtualPythonEnv._populate_pip_requirements(dependency, suffix, actual_os)
+
+        # We need to make separate files because pip accepts either files containing hashes for all or none of the packages
+        requirements_basic_txt = []
+        requirements_hashes_txt = []
+
+        for package_name, package_desc in pip_requirements.items():
+            package_requirement = ""
+            packages_hashes = []
+
+            if "url" in package_desc:
+                package_requirement = f"{package_name}@{package_desc['url']}"
+            elif "version" in package_desc:
+                package_requirement = f"{package_name}=={package_desc['version']}"
+            else:
+                package_requirement = package_name
+
+            if "hashes" in package_desc:
+                for hash_str in package_desc["hashes"]:
+                    packages_hashes.append(f"--hash={hash_str}")
+
+            destination_file = requirements_hashes_txt if len(packages_hashes) > 0 else requirements_basic_txt
+            destination_file.append(' '.join([package_requirement] + packages_hashes))
+
+        generated_files = []
+        self._make_pip_requirements_file(requirements_basic_txt, "basic", suffix, generated_files)
+        self._make_pip_requirements_file(requirements_hashes_txt, "hashes", suffix, generated_files)
+
+        return generated_files
+
+
+    def _make_pip_requirements_file(self, requirements_txt, requirements_type, suffix, generated_files):
+        if len(requirements_txt) > 0:
+            file_suffixes = [file_suffix for file_suffix in [suffix, requirements_type] if file_suffix is not None]
+            file_path = os.path.abspath(f"pip_requirements_{suffix}_{requirements_type}.txt")
+            self.conanfile.output.info(f"Generating pip requirements file at '{file_path}'")
+            save(self.conanfile, file_path, "\n".join(requirements_txt))
+            generated_files.append(file_path)
+
+
+    @staticmethod
+    def _populate_pip_requirements(conanfile, suffix, actual_os):
+        pip_requirements = {}
+        data_key = f"pip_requirements_{suffix}"
+
+        if hasattr(conanfile, "conan_data") and data_key in conanfile.conan_data:
+            pip_requirements_data = conanfile.conan_data[data_key]
+            for system in (system for system in pip_requirements_data if system in ("any_os", actual_os)):
+                for package_name, package_desc in pip_requirements_data[system].items():
+
+                    try:
+                        actual_package_version = Version(pip_requirements[package_name]["version"])
+                    except KeyError:
+                        actual_package_version = None
+
+                    new_package_version = Version(package_desc["version"]) if "version" in package_desc else None
+
+                    if (actual_package_version is None or
+                            (actual_package_version is not None and new_package_version is not None and new_package_version > actual_package_version)):
+                        pip_requirements[package_name] = package_desc
+
+        return pip_requirements
diff --git a/generators/GitHubActionsBuildEnv.py b/generators/GitHubActionsBuildEnv.py
deleted file mode 100644
index d7b7305..0000000
--- a/generators/GitHubActionsBuildEnv.py
+++ /dev/null
@@ -1,30 +0,0 @@
-from pathlib import Path
-
-from jinja2 import Template
-
-from conan.tools.env import VirtualBuildEnv
-from conans.model import Generator
-
-
-class GitHubActionsBuildEnv(Generator):
-
-    @property
-    def filename(self):
-        filepath = str(Path(self.conanfile.generators_folder).joinpath("activate_github_actions_buildenv"))
-        if self.conanfile.settings.get_safe("os") == "Windows":
-            if self.conanfile.conf.get("tools.env.virtualenv:powershell", check_type = bool):
-                filepath += ".ps1"
-            else:
-                filepath += ".bat"
-        else:
-            filepath += ".sh"
-        return filepath
-
-    @property
-    def content(self):
-        template = Template("""{% for k, v in envvars.items() %}echo "{{ k }}={{ v }}" >> ${{ env_prefix }}GITHUB_ENV\n{% endfor %}""")
-        build_env = VirtualBuildEnv(self.conanfile)
-        env = build_env.environment()
-        envvars = env.vars(self.conanfile, scope = "build")
-        env_prefix = "Env:" if self.conanfile.settings.os == "Windows" else ""
-        return template.render(envvars = envvars, env_prefix = env_prefix)
diff --git a/generators/GitHubActionsRunEnv.py b/generators/GitHubActionsRunEnv.py
deleted file mode 100644
index b79a130..0000000
--- a/generators/GitHubActionsRunEnv.py
+++ /dev/null
@@ -1,30 +0,0 @@
-from pathlib import Path
-
-from jinja2 import Template
-
-from conan.tools.env import VirtualRunEnv
-from conans.model import Generator
-
-
-class GitHubActionsRunEnv(Generator):
-
-    @property
-    def filename(self):
-        filepath = str(Path(self.conanfile.generators_folder).joinpath("activate_github_actions_runenv"))
-        if self.conanfile.settings.get_safe("os") == "Windows":
-            if self.conanfile.conf.get("tools.env.virtualenv:powershell", check_type = bool):
-                filepath += ".ps1"
-            else:
-                filepath += ".bat"
-        else:
-            filepath += ".sh"
-        return filepath
-
-    @property
-    def content(self):
-        template = Template("""{% for k, v in envvars.items() %}echo "{{ k }}={{ v }}" >> ${{ env_prefix }}GITHUB_ENV\n{% endfor %}""")
-        build_env = VirtualRunEnv(self.conanfile)
-        env = build_env.environment()
-        envvars = env.vars(self.conanfile, scope = "run")
-        env_prefix = "Env:" if self.conanfile.settings.os == "Windows" else ""
-        return template.render(envvars = envvars, env_prefix = env_prefix)
diff --git a/generators/VirtualPythonEnv.py b/generators/VirtualPythonEnv.py
deleted file mode 100644
index d257a18..0000000
--- a/generators/VirtualPythonEnv.py
+++ /dev/null
@@ -1,174 +0,0 @@
-import sys
-
-import os
-from io import StringIO
-
-from pathlib import Path
-
-from jinja2 import Template
-
-from conan.tools.env import VirtualRunEnv
-from conans.model import Generator
-from conans.errors import ConanException
-
-
-class VirtualPythonEnv(Generator):
-    @property
-    def _script_ext(self):
-        if self.conanfile.settings.get_safe("os") == "Windows":
-            return ".ps1"
-        return ".sh"
-
-    @property
-    def _venv_path(self):
-        if self.settings.os == "Windows":
-            return "Scripts"
-        return "bin"
-
-    @property
-    def filename(self):
-        pass
-
-    @property
-    def content(self):
-        python_interpreter = Path(self.conanfile.deps_user_info["cpython"].python)
-
-        # When on Windows execute as Windows Path
-        if self.conanfile.settings.os == "Windows":
-            python_interpreter = Path(*[f'"{p}"' if " " in p else p for p in python_interpreter.parts])
-
-        # Create the virtual environment
-        if self.conanfile.in_local_cache:
-            venv_folder = self.conanfile.install_folder
-        else:
-            venv_folder = self.conanfile.build_folder if self.conanfile.build_folder else Path(os.getcwd(), "venv")
-
-        self.conanfile.output.info(f"Creating virtual environment in {venv_folder}")
-        run_env = VirtualRunEnv(self.conanfile)
-        env = run_env.environment()
-        sys_vars = env.vars(self.conanfile, scope = "run")
-
-        with sys_vars.apply():
-            self.conanfile.run(f"""{python_interpreter} -m venv {venv_folder}""", scope = "run")
-
-        # Make sure there executable is named the same on all three OSes this allows it to be called with `python`
-        # simplifying GH Actions steps
-        if self.conanfile.settings.os != "Windows":
-            python_venv_interpreter = Path(venv_folder, self._venv_path, "python")
-            if not python_venv_interpreter.exists():
-                python_venv_interpreter.hardlink_to(
-                    Path(venv_folder, self._venv_path, Path(sys.executable).stem + Path(sys.executable).suffix))
-        else:
-            python_venv_interpreter = Path(venv_folder, self._venv_path, Path(sys.executable).stem + Path(sys.executable).suffix)
-
-        if not python_venv_interpreter.exists():
-            raise ConanException(f"Virtual environment Python interpreter not found at: {python_venv_interpreter}")
-        if self.conanfile.settings.os == "Windows":
-            python_venv_interpreter = Path(*[f'"{p}"' if " " in p else p for p in python_venv_interpreter.parts])
-
-        buffer = StringIO()
-        outer = '"' if self.conanfile.settings.os == "Windows" else "'"
-        inner = "'" if self.conanfile.settings.os == "Windows" else '"'
-        with sys_vars.apply():
-            self.conanfile.run(f"""{python_venv_interpreter} -c {outer}import sysconfig; print(sysconfig.get_path({inner}purelib{inner})){outer}""",
-                          env = "conanrun",
-                          output = buffer)
-        pythonpath = buffer.getvalue().splitlines()[-1]
-
-        if hasattr(self.conanfile, f"_{self.conanfile.name}_run_env"):
-            project_run_env = getattr(self.conanfile, f"_{self.conanfile.name}_run_env")
-            if project_run_env:
-                env.compose_env(project_run_env)  # TODO: Add logic for dependencies
-
-        env.define_path("VIRTUAL_ENV", venv_folder)
-        env.prepend_path("PATH", os.path.join(venv_folder, self._venv_path))
-        env.prepend_path("LD_LIBRARY_PATH", os.path.join(venv_folder, self._venv_path))
-        env.prepend_path("DYLD_LIBRARY_PATH", os.path.join(venv_folder, self._venv_path))
-        env.prepend_path("PYTHONPATH", pythonpath)
-        env.unset("PYTHONHOME")
-        venv_vars = env.vars(self.conanfile, scope = "run")
-
-        # Install some base_packages
-        with venv_vars.apply():
-            self.conanfile.run(f"""{python_venv_interpreter} -m pip install wheel setuptools""", env = "conanrun")
-
-        # Install pip_requirements from dependencies
-        for dep_name in reversed(self.conanfile.deps_user_info):
-            dep_user_info = self.conanfile.deps_user_info[dep_name]
-            if len(dep_user_info.vars) == 0:
-                continue
-            pip_req_paths = [self.conanfile.deps_cpp_info[dep_name].res_paths[i] for i, req_path in
-                             enumerate(self.conanfile.deps_cpp_info[dep_name].resdirs) if req_path.endswith("pip_requirements")]
-            if len(pip_req_paths) != 1:
-                continue
-            pip_req_base_path = Path(pip_req_paths[0])
-            if hasattr(dep_user_info, "pip_requirements"):
-                req_txt = pip_req_base_path.joinpath(dep_user_info.pip_requirements)
-                if req_txt.exists():
-                    with venv_vars.apply():
-                        self.conanfile.run(f"{python_venv_interpreter} -m pip install -r {req_txt} --upgrade", env = "conanrun")
-                    self.conanfile.output.success(f"Dependency {dep_name} specifies pip_requirements in user_info installed!")
-                else:
-                    self.conanfile.output.warn(f"Dependency {dep_name} specifies pip_requirements in user_info but {req_txt} can't be found!")
-
-            if hasattr(dep_user_info, "pip_requirements_git"):
-                req_txt = pip_req_base_path.joinpath(dep_user_info.pip_requirements_git)
-                if req_txt.exists():
-                    with venv_vars.apply():
-                        self.conanfile.run(f"{python_venv_interpreter} -m pip install -r {req_txt} --upgrade", env = "conanrun")
-                    self.conanfile.output.success(f"Dependency {dep_name} specifies pip_requirements_git in user_info installed!")
-                else:
-                    self.conanfile.output.warn(
-                        f"Dependency {dep_name} specifies pip_requirements_git in user_info but {req_txt} can't be found!")
-
-            if hasattr(dep_user_info, "pip_requirements_build"):
-                req_txt = pip_req_base_path.joinpath(dep_user_info.pip_requirements_build)
-                if req_txt.exists():
-                    with venv_vars.apply():
-                        self.conanfile.run(f"{python_venv_interpreter} -m pip install -r {req_txt} --upgrade", env = "conanrun")
-                    self.conanfile.output.success(f"Dependency {dep_name} specifies pip_requirements_build in user_info installed!")
-                else:
-                    self.conanfile.output.warn(
-                        f"Dependency {dep_name} specifies pip_requirements_build in user_info but {req_txt} can't be found!")
-
-        if not self.conanfile.in_local_cache and hasattr(self.conanfile, "requirements_txts"):
-            # Install the Python requirements of the current conanfile requirements*.txt
-            pip_req_base_path = Path(self.conanfile.source_folder)
-
-            for req_path in sorted(self.conanfile.requirements_txts, reverse = True):
-                req_txt = pip_req_base_path.joinpath(req_path)
-                if req_txt.exists():
-                    with venv_vars.apply():
-                        self.conanfile.run(f"{python_venv_interpreter} -m pip install -r {req_txt} --upgrade", env = "conanrun")
-                    self.conanfile.output.success(f"Requirements file {req_txt} installed!")
-                else:
-                    self.conanfile.output.warn(f"Requirements file {req_txt} can't be found!")
-
-        # Add all dlls/dylibs/so found in site-packages to the PATH, DYLD_LIBRARY_PATH and LD_LIBRARY_PATH
-        dll_paths = list({ dll.parent for dll in Path(pythonpath).glob("**/*.dll") })
-        for dll_path in dll_paths:
-            env.append_path("PATH", str(dll_path))
-
-        dylib_paths = list({ dylib.parent for dylib in Path(pythonpath).glob("**/*.dylib") })
-        for dylib_path in dylib_paths:
-            env.append_path("DYLD_LIBRARY_PATH", str(dylib_path))
-
-        so_paths = list({ so.parent for so in Path(pythonpath).glob("**/*.dylib") })
-        for so_path in so_paths:
-            env.append_path("LD_LIBRARY_PATH", str(so_path))
-
-        full_envvars = env.vars(self.conanfile, scope = "conanrun")
-
-        # Generate the Python Virtual Environment Script
-        full_envvars.save_sh(Path(venv_folder, self._venv_path, "activate"))
-        full_envvars.save_bat(Path(venv_folder, self._venv_path, "activate.bat"))
-        full_envvars.save_ps1(Path(venv_folder, self._venv_path, "Activate.ps1"))
-
-        # Generate the GitHub Action activation script
-        env_prefix = "Env:" if self.conanfile.settings.os == "Windows" else ""
-        activate_github_actions_buildenv = Template(r"""{% for var, value in envvars.items() %}echo "{{ var }}={{ value }}" >> ${{ env_prefix }}GITHUB_ENV
-{% endfor %}""").render(envvars = full_envvars, env_prefix = env_prefix)
-
-        return {
-            str(Path(venv_folder, self._venv_path, f"activate_github_actions_env{self._script_ext}")): activate_github_actions_buildenv
-        }
diff --git a/global.conf b/global.conf
index 33886ac..04d10c8 100644
--- a/global.conf
+++ b/global.conf
@@ -1,11 +1,5 @@
 core:default_profile = cura.jinja
 core:default_build_profile = cura_build.jinja
 tools.cmake.cmaketoolchain:generator = Ninja
-tools.env.virtualenv:auto_use = True
 tools.gnu:define_libcxx11_abi = True
-tools.build:skip_test = False
-
-# FIXME: Needs to be commented out for OpenSSL to work but if we wan't to create ps1 scripts it needs to be set to True
-# Otherwise .bat files are created. Maybe we should define this on a recipe basis:
-#
-#{% if platform.system() == 'Windows' %}tools.env.virtualenv:powershell=True{% endif %}
+core.version_ranges:resolve_prereleases=True
diff --git a/profiles/cura.jinja b/profiles/cura.jinja
index 4bfe850..bc2c743 100644
--- a/profiles/cura.jinja
+++ b/profiles/cura.jinja
@@ -1,24 +1,37 @@
 include(default)
 
-[build_requires]
-
 [settings]
 compiler.cppstd=17
-curaengine:compiler.cppstd=20
 curaengine*:compiler.cppstd=20
-curaengine_plugin_infill_generate:compiler.cppstd=20
-curaengine_plugin_gradual_flow:compiler.cppstd=20
-curaengine_grpc_definitions:compiler.cppstd=20
-scripta:compiler.cppstd=20
+curaengine_plugin_infill_generate*:compiler.cppstd=20
+curaengine_plugin_gradual_flow*:compiler.cppstd=20
+curaengine_grpc_definitions*:compiler.cppstd=20
+scripta*:compiler.cppstd=20
 umspatial*:compiler.cppstd=20
-dulcificum:compiler.cppstd=20
-cura_settings:compiler.cppstd=20
+dulcificum*:compiler.cppstd=20
+curator*:compiler.cppstd=20
 
-{% if compiler == 'gcc' %}compiler.libcxx=libstdc++11
-{% elif compiler == 'apple-clang' %}compiler.libcxx=libc++
-{% elif compiler == 'Visual Studio' %}compiler.toolset=v143
-{% endif %}
 [options]
-[env]
-
-[conf]
+asio-grpc/*:local_allocator=recycling_allocator
+grpc/*:csharp_plugin=False
+grpc/*:node_plugin=False
+grpc/*:objective_c_plugin=False
+grpc/*:php_plugin=False
+grpc/*:ruby_plugin=False
+grpc/*:python_plugin=False
+boost/*:header_only=True
+{% if platform.system() == 'Linux' %}
+openssl/*:shared=True
+{% endif %}
+pyarcus/*:shared=True
+pysavitar/*:shared=True
+pynest2d/*:shared=True
+cpython/*:shared=True
+cpython/*:with_tkinter=False
+cpython/*:with_curses=False
+{% if platform.system() == 'Windows' %}
+dulcificum/*:shared=False
+{% else %}
+dulcificum/*:shared=True
+{% endif %}
+clipper/*:shared=True
diff --git a/profiles/cura_build.jinja b/profiles/cura_build.jinja
index c747fd0..de80517 100644
--- a/profiles/cura_build.jinja
+++ b/profiles/cura_build.jinja
@@ -1,15 +1,4 @@
 include(default)
 
-[build_requires]
-
 [settings]
 compiler.cppstd=17
-{% if compiler == 'gcc' %}compiler.libcxx=libstdc++11
-{% elif compiler == 'apple-clang' %}compiler.libcxx=libc++
-{% elif compiler == 'Visual Studio' %}compiler.toolset=v143
-{% endif %}
-[options]
-
-[env]
-
-[conf]
diff --git a/profiles/cura_clang.jinja b/profiles/cura_clang.jinja
new file mode 100644
index 0000000..fc7eaaa
--- /dev/null
+++ b/profiles/cura_clang.jinja
@@ -0,0 +1,13 @@
+include(cura.jinja)
+
+[tool_requires]
+
+[settings]
+compiler=clang
+compiler.version=18
+compiler.libcxx=libstdc++11
+
+[options]
+
+[conf]
+tools.build:compiler_executables={"c":"clang", "cpp":"clang++"}
diff --git a/profiles/cura_wasm.jinja b/profiles/cura_wasm.jinja
new file mode 100644
index 0000000..372fc79
--- /dev/null
+++ b/profiles/cura_wasm.jinja
@@ -0,0 +1,19 @@
+include(cura.jinja)
+
+[tool_requires]
+emsdk/3.1.65@ultimaker/stable
+nodejs/20.16.0@ultimaker/stable
+
+[settings]
+os=Emscripten
+arch=wasm
+
+[conf]
+tools.build:skip_test=True
+
+[options]
+curaengine/*:enable_plugins=False
+curaengine/*:enable_arcus=False
+curator/*:with_cura_resources=True
+curator/*:disable_logging=True
+libzip/*:crypto=False
diff --git a/profiles/installer.jinja b/profiles/installer.jinja
new file mode 100644
index 0000000..40fd3f8
--- /dev/null
+++ b/profiles/installer.jinja
@@ -0,0 +1,22 @@
+include(cura.jinja)
+
+[conf]
+tools.build:skip_test=True
+user.sentry:url=https://734f9ec9024f73e53701d59c3ffddfe3@o323038.ingest.sentry.io/4506257745510401
+user.sentry:organization=ultimaker-o7
+
+[options]
+curaengine/*:enable_sentry=True
+curaengine/*:sentry_send_binaries=True
+curaengine/*:sentry_create_release=True
+arcus/*:enable_sentry=True
+arcus/*:sentry_send_binaries=True
+arcus/*:sentry_project=curaengine
+clipper/*:enable_sentry=True
+clipper/*:sentry_send_binaries=True
+clipper/*:sentry_project=curaengine
+
+[settings]
+curaengine/*:build_type=RelWithDebInfo
+arcus/*:build_type=RelWithDebInfo
+clipper/*:build_type=RelWithDebInfo
diff --git a/remotes.json b/remotes.json
new file mode 100644
index 0000000..e0f7f4a
--- /dev/null
+++ b/remotes.json
@@ -0,0 +1,20 @@
+{
+ "remotes": [
+  {
+   "name": "conancenter",
+   "url": "https://center2.conan.io",
+   "verify_ssl": true
+  },
+  {
+   "name": "cura-conan2",
+   "url": "https://cura.jfrog.io/artifactory/api/conan/cura-conan2-dev",
+   "verify_ssl": true
+  },
+  {
+   "name": "cura-private-conan2",
+   "url": "https://cura.jfrog.io/artifactory/api/conan/cura-private-conan2-dev",
+   "verify_ssl": true,
+   "disabled": true
+  }
+ ]
+}
diff --git a/remotes.txt b/remotes.txt
deleted file mode 100644
index 0a63ed6..0000000
--- a/remotes.txt
+++ /dev/null
@@ -1 +0,0 @@
-cura https://cura.jfrog.io/artifactory/api/conan/cura-conan-dev True