i18n cleanup for BCASL and Cleaner; add simple engines UI-state persistence:\n- Core: default ARK config includes engines (pyinstaller, nuitka, cx_freeze) UI widgets\n- Registry: apply saved widgets on tab creation; expose save_engine_ui\n- SDK: provide save_engine_ui() helper for engines\n- Engines: PyInstaller, Nuitka, cx_Freeze auto-save widget state (checked/text/index)\n- Remove obsolete ACASL hooks and BCASL i18n propagation

Author: PyCompiler ARK++

Core/ark_config_loader.py

@@ -115,6 +115,20 @@
         "bcasl_enabled": True,
         "plugin_timeout": 0.0,
     },
+
+    # Engines UI state (persisted widget states per engine)
+    "engines": {
+        "pyinstaller": {
+            "ui": {
+                "widgets": {}
+            }
+        },
+        "nuitka": {
+            "ui": {
+                "widgets": {}
+            }
+        }
+    },
 }
 
 
@@ -335,6 +349,15 @@ def create_default_ark_config(workspace_dir: str) -> bool:
     - "pip"
   auto_detect: true
   fallback_to_pip: true
+
+# ENGINES (UI state persistence)
+engines:
+  pyinstaller:
+    ui:
+      widgets: {}
+  nuitka:
+    ui:
+      widgets: {}
 """
 
         with open(config_file, 'w', encoding='utf-8') as f:
@@ -345,3 +368,92 @@ def create_default_ark_config(workspace_dir: str) -> bool:
     except Exception as e:
         print(f"Warning: Failed to create ARK_Main_Config.yml: {e}")
         return False
+
+
+# --- Simple Engine UI state helpers (for non-dev friendly persistence) ---
+
+def _read_yaml(path: Path) -> dict:
+    try:
+        if path.exists():
+            with open(path, 'r', encoding='utf-8') as f:
+                data = yaml.safe_load(f) or {}
+                return data if isinstance(data, dict) else {}
+    except Exception:
+        pass
+    return {}
+
+
+def _write_yaml_atomic(path: Path, data: dict) -> bool:
+    try:
+        path.parent.mkdir(parents=True, exist_ok=True)
+        tmp = path.with_suffix(path.suffix + ".tmp")
+        with open(tmp, 'w', encoding='utf-8') as f:
+            yaml.safe_dump(data, f, allow_unicode=True, sort_keys=False)
+        os.replace(tmp, path)
+        return True
+    except Exception:
+        return False
+
+
+essential_props = ("checked", "text", "enabled", "visible", "currentIndex")
+
+
+def load_engine_ui_state(workspace_dir: str, engine_id: str) -> dict:
+    """Load saved UI state for an engine from ARK_Main_Config.yml.
+    Returns a mapping {widgetName: {prop: value}} or {}.
+    """
+    try:
+        cfg = _read_yaml(Path(workspace_dir) / "ARK_Main_Config.yml") if workspace_dir else {}
+        engines = cfg.get("engines", {}) if isinstance(cfg, dict) else {}
+        e = engines.get(str(engine_id), {}) if isinstance(engines, dict) else {}
+        ui = e.get("ui", {}) if isinstance(e, dict) else {}
+        widgets = ui.get("widgets", {}) if isinstance(ui, dict) else {}
+        return widgets if isinstance(widgets, dict) else {}
+    except Exception:
+        return {}
+
+
+def save_engine_ui_state(workspace_dir: str, engine_id: str, updates: dict) -> bool:
+    """Save UI state for an engine into ARK_Main_Config.yml.
+    - workspace_dir: project workspace path
+    - engine_id: id string (e.g. 'pyinstaller')
+    - updates: {widgetName: {prop: value}}
+    Returns True on success, False otherwise.
+    """
+    if not workspace_dir:
+        return False
+    try:
+        cfg_path = Path(workspace_dir) / "ARK_Main_Config.yml"
+        cfg = _read_yaml(cfg_path)
+        if not isinstance(cfg, dict):
+            cfg = {}
+        engines = cfg.get("engines")
+        if not isinstance(engines, dict):
+            engines = {}
+            cfg["engines"] = engines
+        e = engines.get(str(engine_id))
+        if not isinstance(e, dict):
+            e = {}
+            engines[str(engine_id)] = e
+        ui = e.get("ui")
+        if not isinstance(ui, dict):
+            ui = {}
+            e["ui"] = ui
+        widgets = ui.get("widgets")
+        if not isinstance(widgets, dict):
+            widgets = {}
+            ui["widgets"] = widgets
+        # Merge per widget
+        for wname, props in (updates or {}).items():
+            if not isinstance(wname, str) or not isinstance(props, dict):
+                continue
+            cur = widgets.get(wname)
+            if not isinstance(cur, dict):
+                cur = {}
+                widgets[wname] = cur
+            for k, v in props.items():
+                if k in essential_props:
+                    cur[k] = v
+        return _write_yaml_atomic(cfg_path, cfg)
+    except Exception:
+        return False

Core/engines_loader/registry.py

@@ -15,9 +15,10 @@
 
 from __future__ import annotations
 
-from typing import Optional
+from typing import Optional, Any
 
 from .base import CompilerEngine
+from Core.ark_config_loader import load_engine_ui_state, save_engine_ui_state
 
 _REGISTRY: dict[str, type[CompilerEngine]] = {}
 _ORDER: list[str] = []
@@ -63,6 +64,49 @@ def register(engine_cls: type[CompilerEngine]):
         return engine_cls
 
 
+def _apply_widgets_state(container, widgets_state: dict) -> None:
+    """Apply basic properties to child widgets given a simple state mapping.
+    Supported props: checked, text, enabled, visible, currentIndex.
+    """
+    try:
+        for wname, props in widgets_state.items():
+            try:
+                w = container.findChild(object, wname)
+                if w is None:
+                    continue
+                for k, v in (props or {}).items():
+                    try:
+                        if k == "checked" and hasattr(w, "setChecked"):
+                            w.setChecked(bool(v))
+                        elif k == "text" and hasattr(w, "setText"):
+                            w.setText(str(v))
+                        elif k == "enabled" and hasattr(w, "setEnabled"):
+                            w.setEnabled(bool(v))
+                        elif k == "visible" and hasattr(w, "setVisible"):
+                            w.setVisible(bool(v))
+                        elif k == "currentIndex" and hasattr(w, "setCurrentIndex"):
+                            w.setCurrentIndex(int(v))
+                    except Exception:
+                        continue
+            except Exception:
+                continue
+    except Exception:
+        pass
+
+
+def save_engine_ui(gui, engine_id: str, updates: dict[str, dict[str, Any]]) -> bool:
+    """Public helper for engines to persist UI state into ARK_Main_Config.yml.
+    Engines pass a mapping {widgetName: {prop: value}}. Returns True on success.
+    """
+    try:
+        ws = getattr(gui, "workspace_dir", None)
+        if not ws:
+            return False
+        return save_engine_ui_state(ws, engine_id, updates)
+    except Exception:
+        return False
+
+
 def get_engine(eid: str) -> Optional[type[CompilerEngine]]:
     try:
         return _REGISTRY.get(eid)
@@ -97,6 +141,15 @@ def bind_tabs(gui) -> None:
                 if not pair:
                     continue
                 widget, label = pair
+                # Apply saved UI state for this engine (simple mapping by objectName)
+                try:
+                    ws = getattr(gui, "workspace_dir", None)
+                    if ws:
+                        widgets_state = load_engine_ui_state(ws, eid)
+                        if isinstance(widgets_state, dict) and widgets_state:
+                            _apply_widgets_state(widget, widgets_state)
+                except Exception:
+                    pass
                 try:
                     existing = tabs.indexOf(widget)
                 except Exception:

ENGINES/cx_freeze/engine.py

@@ -797,6 +797,14 @@ def create_tab(self, gui):
         row = QHBoxLayout()
         out_edit = QLineEdit()
         out_edit.setObjectName("cx_output_dir")
+        # Persist changes to ARK config
+        try:
+            from engine_sdk import save_engine_ui as _save
+            out_edit.textChanged.connect(
+                lambda s: _save(gui, "cx_freeze", {"cx_output_dir": {"text": str(s)}})
+            )
+        except Exception:
+            pass
         try:
             out_edit.setPlaceholderText(
                 gui.tr(
@@ -859,6 +867,14 @@ def _browse():
             self._cx_tn_label = None
         tn_edit = QLineEdit()
         tn_edit.setObjectName("cx_target_name")
+        # Persist target name
+        try:
+            from engine_sdk import save_engine_ui as _save
+            tn_edit.textChanged.connect(
+                lambda s: _save(gui, "cx_freeze", {"cx_target_name": {"text": str(s)}})
+            )
+        except Exception:
+            pass
         try:
             tn_edit.setPlaceholderText(
                 gui.tr(
@@ -875,6 +891,15 @@ def _browse():
         row2 = QHBoxLayout()
         base_label = QLabel(gui.tr("Base", "Base"))
         base_combo = QComboBox()
+        base_combo.setObjectName("cx_base_combo")
+        # Persist base combo index
+        try:
+            from engine_sdk import save_engine_ui as _save
+            base_combo.currentIndexChanged.connect(
+                lambda idx: _save(gui, "cx_freeze", {"cx_base_combo": {"currentIndex": int(idx)}})
+            )
+        except Exception:
+            pass
         try:
             if platform.system() == "Windows":
                 base_combo.addItems(["Console", "Win32GUI"])
@@ -883,11 +908,27 @@ def _browse():
         except Exception:
             pass
         cb_deps = QCheckBox(gui.tr("Inclure dépendances", "Include dependencies"))
+        # Persist deps toggle
+        try:
+            from engine_sdk import save_engine_ui as _save
+            cb_deps.toggled.connect(
+                lambda v: _save(gui, "cx_freeze", {"cx_include_deps": {"checked": bool(v)}})
+            )
+        except Exception:
+            pass
         try:
             cb_deps.setChecked(True)
         except Exception:
             pass
         cb_enc = QCheckBox(gui.tr("Inclure encodings", "Include encodings"))
+        # Persist encodings toggle
+        try:
+            from engine_sdk import save_engine_ui as _save
+            cb_enc.toggled.connect(
+                lambda v: _save(gui, "cx_freeze", {"cx_include_encodings": {"checked": bool(v)}})
+            )
+        except Exception:
+            pass
         row2.addWidget(base_label)
         row2.addWidget(base_combo)
         row2.addStretch(1)
@@ -908,6 +949,15 @@ def _browse():
         except Exception:
             self._cx_icon_title = None
         icon_edit = QLineEdit()
+        icon_edit.setObjectName("cx_icon_path")
+        # Persist icon path
+        try:
+            from engine_sdk import save_engine_ui as _save
+            icon_edit.textChanged.connect(
+                lambda s: _save(gui, "cx_freeze", {"cx_icon_path": {"text": str(s)}})
+            )
+        except Exception:
+            pass
         icon_btn = QPushButton(gui.tr("Parcourir…", "Browse…"))
         self._cx_icon_browse_btn = icon_btn
 
@@ -945,6 +995,15 @@ def _browse_icon():
         except Exception:
             self._cx_optimize_title = None
         opt_combo = QComboBox()
+        opt_combo.setObjectName("cx_optimize_level")
+        # Persist optimization level
+        try:
+            from engine_sdk import save_engine_ui as _save
+            opt_combo.currentIndexChanged.connect(
+                lambda idx: _save(gui, "cx_freeze", {"cx_optimize_level": {"currentIndex": int(idx)}})
+            )
+        except Exception:
+            pass
         opt_combo.addItems(["0", "1", "2"])  # python -O / -OO equivalent
         opt_row.addWidget(opt_combo)
         opt_row.addStretch(1)

ENGINES/nuitka/engine.py

@@ -424,6 +424,39 @@ def create_tab(self, gui):
 
             tab = getattr(gui, "tab_nuitka", None)
             if tab and isinstance(tab, QWidget):
+                # Save UI state automatically when user toggles/edits widgets
+                try:
+                    from engine_sdk import save_engine_ui as _save
+                    # Checkboxes for nuitka
+                    for _name in (
+                        "nuitka_onefile",
+                        "nuitka_standalone",
+                        "nuitka_disable_console",
+                        "nuitka_show_progress",
+                    ):
+                        try:
+                            _w = getattr(gui, _name, None)
+                            if _w is not None and hasattr(_w, "toggled"):
+                                _w.toggled.connect(
+                                    lambda v, n=_name: _save(
+                                        gui, "nuitka", {n: {"checked": bool(v)}}
+                                    )
+                                )
+                        except Exception:
+                            pass
+                    # Output dir for nuitka
+                    try:
+                        _w = getattr(gui, "nuitka_output_dir", None)
+                        if _w is not None and hasattr(_w, "textChanged"):
+                            _w.textChanged.connect(
+                                lambda s: _save(
+                                    gui, "nuitka", {"nuitka_output_dir": {"text": str(s)}}
+                                )
+                            )
+                    except Exception:
+                        pass
+                except Exception:
+                    pass
                 return tab, _tr("Nuitka", "Nuitka")
         except Exception:
             pass

ENGINES/pyinstaller/engine.py

@@ -303,6 +303,43 @@ def create_tab(self, gui):
 
             tab = getattr(gui, "tab_pyinstaller", None)
             if tab and isinstance(tab, QWidget):
+                # Save UI state automatically when user toggles/edits widgets
+                try:
+                    from engine_sdk import save_engine_ui as _save
+                    # Checkboxes to persist
+                    for _name in (
+                        "opt_onefile",
+                        "opt_windowed",
+                        "opt_noconfirm",
+                        "opt_clean",
+                        "opt_noupx",
+                        "opt_debug",
+                    ):
+                        try:
+                            _w = getattr(gui, _name, None)
+                            if _w is not None and hasattr(_w, "toggled"):
+                                _w.toggled.connect(
+                                    lambda v, n=_name: _save(
+                                        gui, "pyinstaller", {n: {"checked": bool(v)}}
+                                    )
+                                )
+                        except Exception:
+                            pass
+                    # Text fields to persist
+                    try:
+                        _w = getattr(gui, "output_dir_input", None)
+                        if _w is not None and hasattr(_w, "textChanged"):
+                            _w.textChanged.connect(
+                                lambda s: _save(
+                                    gui,
+                                    "pyinstaller",
+                                    {"output_dir_input": {"text": str(s)}},
+                                )
+                            )
+                    except Exception:
+                        pass
+                except Exception:
+                    pass
                 return tab, gui.tr("PyInstaller", "PyInstaller")
         except Exception:
             pass