Upload 4 files

Source Code/QToggle.py

@@ -0,0 +1,203 @@
+"""
+Author: Luan Dias - https://github.com/luandiasrj
+Url: https://github.com/luandiasrj/QToggle_-_Advanced_QCheckbox_for_PyQT6
+
+This code implements a custom QToggle class, which is a toggle switch derived
+from QCheckBox. The QToggle class features customizable colors, and properties.
+It includes smooth transitions when toggling between states.
+
+The custom properties include:
+
+    bg_color: background color of the toggle
+    circle_color: color of the circle inside the toggle
+    active_color: color of the background when the toggle is checked
+    disabled_color: color of the toggle when it's disabled
+    text_color: color of the text
+
+Main functions and methods in the class include:
+
+    init: Initializes the QToggle object with default colors and settings
+    setDuration: Set the duration for the animation
+    update_pos_color: Updates the circle position and background color
+    start_transition: Starts the transition animation when the state changes
+    create_animation: Creates the circle position animation
+    create_bg_color_animation: Creates the background color animation
+    sizeHint: Provides the recommended size for the toggle
+    hitButton: Determines if the mouse click is inside the toggle area
+    paintEvent: Handles the custom painting of the toggle
+
+The example demonstrates how to use the QToggle class by creating three
+different toggles with various settings such as custom height, colors, and font.
+"""
+
+from PyQt6.QtCore import Qt, QRect, pyqtProperty, QPropertyAnimation, QPoint, \
+    QEasingCurve
+from PyQt6.QtGui import QColor, QFontMetrics, QPainter, QPainterPath, QBrush, \
+    QPen, QFont
+from PyQt6.QtWidgets import QApplication, QWidget, QCheckBox, QVBoxLayout
+
+
+class QToggle(QCheckBox):
+    bg_color = pyqtProperty(
+        QColor, lambda self: self._bg_color,
+        lambda self, col: setattr(self, '_bg_color', col))
+    circle_color = pyqtProperty(
+        QColor, lambda self: self._circle_color,
+        lambda self, col: setattr(self, '_circle_color', col))
+    active_color = pyqtProperty(
+        QColor, lambda self: self._active_color,
+        lambda self, col: setattr(self, '_active_color', col))
+    disabled_color = pyqtProperty(
+        QColor, lambda self: self._disabled_color,
+        lambda self, col: setattr(self, '_disabled_color', col))
+    text_color = pyqtProperty(
+        QColor, lambda self: self._text_color,
+        lambda self, col: setattr(self, '_text_color', col))
+
+    def __init__(self, parent=None):
+        super().__init__(parent)
+        self._bg_color, self._circle_color, self._active_color, \
+            self._disabled_color, self._text_color = QColor("#0BF"), \
+            QColor("#DDD"), QColor('#777'), QColor("#CCC"), QColor("#000")
+        self._circle_pos, self._intermediate_bg_color = None, None
+        self.setFixedHeight(18)
+        self._animation_duration = 500  # milliseconds
+        self.stateChanged.connect(self.start_transition)
+        self._user_checked = False  # Introduced flag to check user-initiated changes
+
+    circle_pos = pyqtProperty(
+        float, lambda self: self._circle_pos,
+        lambda self, pos: (setattr(self, '_circle_pos', pos), self.update()))
+    intermediate_bg_color = pyqtProperty(
+        QColor, lambda self: self._intermediate_bg_color,
+        lambda self, col: setattr(self, '_intermediate_bg_color', col))
+
+    def setDuration(self, duration: int):
+        """
+        Set the duration for the animation.
+        :param duration: Duration in milliseconds.
+        """
+        self._animation_duration = duration
+
+    def update_pos_color(self, checked=None):
+        self._circle_pos = self.height() * (1.1 if checked else 0.1)
+        if self.isChecked():
+            self._intermediate_bg_color = self._active_color
+        else:
+            self._intermediate_bg_color = self._bg_color
+
+    def start_transition(self, state):
+        if not self._user_checked:  # Skip animation if change isn't user-initiated
+            self.update_pos_color(state)
+            return
+        for anim in [self.create_animation, self.create_bg_color_animation]:
+            animation = anim(state)
+            animation.start()
+        self._user_checked = False  # Reset the flag after animation starts
+
+    def mousePressEvent(self, event):
+        self._user_checked = True  # Set flag when user manually clicks the toggle
+        super().mousePressEvent(event)
+
+    def create_animation(self, state):
+        return self._create_common_animation(
+            state, b'circle_pos', self.height() * 0.1, self.height() * 1.1)
+
+    def create_bg_color_animation(self, state):
+        return self._create_common_animation(
+            state, b'intermediate_bg_color', self._bg_color, self._active_color)
+
+    def _create_common_animation(self, state, prop, start_val, end_val):
+        animation = QPropertyAnimation(self, prop, self)
+        animation.setEasingCurve(QEasingCurve.Type.InOutCubic)
+        animation.setDuration(self._animation_duration)
+        animation.setStartValue(start_val if state else end_val)
+        animation.setEndValue(end_val if state else start_val)
+        return animation
+
+    def showEvent(self, event):
+        super().showEvent(event)  # Ensure to call the super class's implementation
+        self.update_pos_color(self.isChecked())
+
+    def resizeEvent(self, event):
+        self.update_pos_color(self.isChecked())
+
+    def sizeHint(self):
+        size = super().sizeHint()
+        text_width = QFontMetrics(
+            self.font()).boundingRect(self.text()).width()
+        size.setWidth(int(self.height() * 2 + text_width * 1.075))
+        return size
+
+    def hitButton(self, pos: QPoint):
+        return self.contentsRect().contains(pos)
+
+    def paintEvent(self, event):
+        painter = QPainter(self)
+        painter.setRenderHint(QPainter.RenderHint.Antialiasing)
+
+        circle_color = QColor(
+            self.disabled_color if not self.isEnabled() else self.circle_color)
+        bg_color = QColor(
+            self.disabled_color if not self.isEnabled() else
+            self.intermediate_bg_color)
+        text_color = QColor(
+            self.disabled_color if not self.isEnabled() else self.text_color)
+
+        bordersradius = self.height() / 2
+        togglewidth = self.height() * 2
+        togglemargin = self.height() * 0.3
+        circlesize = self.height() * 0.8
+
+        bg_path = QPainterPath()
+        bg_path.addRoundedRect(
+            0, 0, togglewidth, self.height(), bordersradius, bordersradius)
+        painter.fillPath(bg_path, QBrush(bg_color))
+
+        circle = QPainterPath()
+        circle.addEllipse(
+            self.circle_pos, self.height() * 0.1, circlesize, circlesize)
+        painter.fillPath(circle, QBrush(circle_color))
+
+        painter.setPen(QPen(QColor(text_color)))
+        painter.setFont(self.font())
+        text_rect = QRect(int(togglewidth + togglemargin), 0, self.width() -
+                          int(togglewidth + togglemargin), self.height())
+        text_rect.adjust(
+            0, (self.height() - painter.fontMetrics().height()) // 2, 0, 0)
+        painter.drawText(text_rect, Qt.AlignmentFlag.AlignLeft |
+                         Qt.AlignmentFlag.AlignVCenter, self.text())
+        painter.end()
+
+
+if __name__ == '__main__':
+    app = QApplication([])
+    window = QWidget()
+    layout = QVBoxLayout()
+
+    checkbox0 = QToggle()
+    checkbox0.setFixedHeight(12)
+    layout.addWidget(checkbox0)
+
+    checkbox1 = QToggle()
+    checkbox1.setText('Checkbox 1 - Disabled')
+    checkbox1.setEnabled(False)
+    layout.addWidget(checkbox1)
+
+    checkbox2 = QToggle()
+    checkbox2.setText('Checkbox 2 - Checked, custom height, animation duration, colors and font')
+    checkbox2.setFixedHeight(24)
+    checkbox2.setFont(QFont('Segoe Print', 10))
+    checkbox2.setStyleSheet("QToggle{"
+                            "qproperty-bg_color:#FAA;"
+                            "qproperty-circle_color:#DDF;"
+                            "qproperty-active_color:#AAF;"
+                            "qproperty-disabled_color:#777;"
+                            "qproperty-text_color:#A0F;}")
+    checkbox2.setDuration(2000)
+    checkbox2.setChecked(True)
+    layout.addWidget(checkbox2)
+
+    window.setLayout(layout)
+    window.show()
+    app.exec()

Source Code/main.py

@@ -0,0 +1,9 @@
+import sys
+from PyQt6.QtWidgets import QApplication
+from ui_loader import UILoader
+
+if __name__ == "__main__":
+	app = QApplication(sys.argv)
+	ui_loader = UILoader()
+	ui_loader.show()
+	sys.exit(app.exec())

Source Code/ui_loader.py

@@ -0,0 +1,132 @@
+from PyQt6.QtWidgets import QMainWindow, QFileDialog
+from PyQt6.QtCore import Qt
+from ui_main import Ui_MainWindow
+import configparser
+import subprocess
+import os
+from PyQt6.QtCore import Qt, QPoint
+from PyQt6.QtWidgets import QStackedWidget
+from PyQt6.QtWidgets import QMainWindow, QFileDialog
+
+class UILoader(QMainWindow, Ui_MainWindow):
+    def __init__(self):
+        super().__init__()
+        self.setupUi(self)
+        self.setWindowFlag(Qt.WindowType.FramelessWindowHint)
+        self.setAttribute(Qt.WidgetAttribute.WA_TranslucentBackground)
+        self.init_ui()
+        self.update_batch_size_label(3)
+        self.update_ctx_size_label(4)
+        #self.load_config()
+        self.offset = None  # Add this line
+
+    def init_ui(self):
+        self.minimize_button.clicked.connect(self.showMinimized)
+        self.close_button.clicked.connect(self.close)
+        self.model_browse_button.clicked.connect(self.browse_model)
+        self.run_server_button.clicked.connect(self.run_server)
+        self.save_config_button.clicked.connect(self.save_config)
+        self.load_config_button.clicked.connect(self.load_config)
+
+        self.top_bar.mousePressEvent = self.mouse_press_event
+        self.top_bar.mouseMoveEvent = self.mouse_move_event
+
+    def mouse_press_event(self, event):
+        self.offset = event.pos()
+
+    def update_threads_label(self, value):
+        self.threads_label.setText(f"Threads: {value + 1}")
+
+    def mouse_move_event(self, event):
+        if self.offset is not None and event.buttons() == Qt.MouseButton.LeftButton:
+            self.move(self.pos() + event.pos() - self.offset)
+
+    def browse_model(self):
+        model_path, _ = QFileDialog.getOpenFileName(self, "Select Model", os.getcwd(), "Model Files (*.gguf)")
+        self.model_path_line_edit.setText(model_path)
+
+    def run_server(self):
+        model_path = self.model_path_line_edit.text()
+        batch_size = self.batch_size_values[self.batch_size_slider.value()]
+        ctx_size = self.ctx_size_values[self.ctx_size_slider.value()]
+        layers_offload = self.layers_offload_spin_box.value()
+        threads = self.threads_spin_box.value()
+        use_flash_attention = self.flash_attention_checkbox.isChecked()
+        is_moe = self.moe_checkbox.isChecked()
+        moe_experts_string = ""
+        if is_moe:
+            experts_use = self.moe_experts_spin_box.value()
+            moe_experts_string = f"--override-kv llama.expert_used_count=int:{experts_use}"
+
+        custom_rope_freq_base = self.rope_freq_base_spin_box.value() if self.rope_freq_base_checkbox.isChecked() else None
+        mlock = self.mlock_checkbox.isChecked()
+        no_mmap = self.no_mmap_checkbox.isChecked()
+        no_kv_offload = self.no_kv_offload_checkbox.isChecked()
+
+        command = [
+            "LlamaCPP\\llama-server.exe",
+            f"--model {model_path}",
+            f"--batch-size {batch_size}",
+            f"--ctx-size {ctx_size}",
+            f"--n-gpu-layers {layers_offload}",
+            f"--threads {threads}",
+        ]
+
+        if use_flash_attention:
+            command.append("--flash-attn")
+        if mlock:
+            command.append("--mlock")
+        if no_mmap:
+            command.append("--no-mmap")
+        if no_kv_offload:
+            command.append("--no-kv-offload")
+        if custom_rope_freq_base is not None:
+            command.append(f"--rope-freq-base {custom_rope_freq_base}")
+        if moe_experts_string:
+            command.append(moe_experts_string)
+
+        print(" ".join(command))
+        subprocess.run(" ".join(command), shell=True)
+
+    def save_config(self):
+        config = configparser.ConfigParser()
+        config["Server"] = {
+            "model_path": self.model_path_line_edit.text(),
+            "batch_size": str(self.batch_size_slider.value()),
+            "ctx_size": str(self.ctx_size_slider.value()),
+            "layers_offload": str(self.layers_offload_spin_box.value()),
+            "threads": str(self.threads_spin_box.value()),
+            "use_flash_attention": str(self.flash_attention_checkbox.isChecked()),
+            "is_moe": str(self.moe_checkbox.isChecked()),
+            "moe_experts": str(self.moe_experts_spin_box.value()),
+            "rope_freq_base_custom": str(self.rope_freq_base_checkbox.isChecked()),
+            "rope_freq_base_value": str(self.rope_freq_base_spin_box.value()),
+            "mlock": str(self.mlock_checkbox.isChecked()),
+            "no_mmap": str(self.no_mmap_checkbox.isChecked()),
+            "no_kv_offload": str(self.no_kv_offload_checkbox.isChecked()),
+        }
+
+        file_path, _ = QFileDialog.getSaveFileName(self, "Save Configuration", os.getcwd(), "INI Files (*.ini)")
+        if file_path:
+            with open(file_path, "w") as config_file:
+                config.write(config_file)
+
+    def load_config(self):
+        file_path, _ = QFileDialog.getOpenFileName(self, "Load Configuration", os.getcwd(), "INI Files (*.ini)")
+        if file_path:
+            config = configparser.ConfigParser()
+            config.read(file_path)
+
+            self.model_path_line_edit.setText(config.get("Server", "model_path", fallback=""))
+            self.batch_size_slider.setValue(config.getint("Server", "batch_size", fallback=512))
+            self.ctx_size_slider.setValue(config.getint("Server", "ctx_size", fallback=8192))
+            self.layers_offload_spin_box.setValue(config.getint("Server", "layers_offload", fallback=22))
+            self.threads_spin_box.setValue(config.getint("Server", "threads", fallback=14))
+            self.flash_attention_checkbox.setChecked(config.getboolean("Server", "use_flash_attention", fallback=False))
+            self.moe_checkbox.setChecked(config.getboolean("Server", "is_moe", fallback=False))
+            self.moe_experts_spin_box.setValue(config.getint("Server", "moe_experts", fallback=1))
+            self.rope_freq_base_checkbox.setChecked(config.getboolean("Server", "rope_freq_base_custom", fallback=False))
+            self.rope_freq_base_spin_box.setValue(config.getint("Server", "rope_freq_base_value", fallback=1))
+            self.mlock_checkbox.setChecked(config.getboolean("Server", "mlock", fallback=False))
+            self.no_mmap_checkbox.setChecked(config.getboolean("Server", "no_mmap", fallback=False))
+            self.no_kv_offload_checkbox.setChecked(config.getboolean("Server", "no_kv_offload", fallback=False))

Source Code/ui_main.py

@@ -0,0 +1,497 @@
+from PyQt6 import QtCore, QtGui, QtWidgets
+import os
+from QToggle import QToggle
+
+class FixedValueSlider(QtWidgets.QSlider):
+    def __init__(self, values, parent=None):
+        super().__init__(QtCore.Qt.Orientation.Horizontal, parent)
+        self.setMinimum(0)
+        self.setMaximum(len(values) - 1)
+        self.setTickPosition(QtWidgets.QSlider.TickPosition.TicksBelow)
+        self.setTickInterval(1)
+        self.values = values
+        self.valueChanged.connect(self.update_value_label)
+
+    def value(self):
+        return self.values[super().value()]
+
+    def setValue(self, value):
+        super().setValue(self.values.index(value))
+
+    def update_value_label(self, index):
+        self.valueChanged.emit(self.values[index])
+
+class Ui_MainWindow(object):
+    def retranslateUi(self, MainWindow):
+        _translate = QtCore.QCoreApplication.translate
+        MainWindow.setWindowTitle(_translate("MainWindow", "MainWindow"))
+        self.title_label.setText(_translate("MainWindow", " 🔵 LLAMACPP SERVER UI"))
+        self.minimize_button.setText(_translate("MainWindow", "-"))
+        self.close_button.setText(_translate("MainWindow", "X"))
+        self.model_path_label.setText(_translate("MainWindow", "Model Path:"))
+        self.model_browse_button.setText(_translate("MainWindow", "Browse"))
+        self.batch_size_label.setText(_translate("MainWindow", "Batch Size:"))
+        self.ctx_size_label.setText(_translate("MainWindow", "Context Size:"))
+        self.layers_offload_label.setText(_translate("MainWindow", "Layers Offload:"))
+        self.threads_label.setText(_translate("MainWindow", "Threads:"))
+        self.flash_attention_checkbox.setText(_translate("MainWindow", "Flash Attention"))
+        self.moe_checkbox.setText(_translate("MainWindow", "Custom MoE Experts"))
+        self.moe_experts_label.setText(_translate("MainWindow", "MoE Active Experts:"))
+        self.rope_freq_base_checkbox.setText(_translate("MainWindow", "Custom RoPE Freq Base"))
+        self.rope_freq_base_label.setText(_translate("MainWindow", "RoPE Freq Base:"))
+        self.mlock_checkbox.setText(_translate("MainWindow", "Use mlock"))
+        self.no_mmap_checkbox.setText(_translate("MainWindow", "Disable MMAP"))
+        self.no_kv_offload_checkbox.setText(_translate("MainWindow", "No KV Offload"))
+        self.run_server_button.setText(_translate("MainWindow", "Run Server"))
+        self.save_config_button.setText(_translate("MainWindow", "Save Config"))
+        self.load_config_button.setText(_translate("MainWindow", "Load Config"))
+    
+    def update_batch_size_label(self, value):
+        self.batch_size_label.setText(f"Batch Size: {self.batch_size_values[value]}")
+
+    def update_ctx_size_label(self, value):
+        self.ctx_size_label.setText(f"Context Size: {self.ctx_size_values[value]}")
+
+    def setupUi(self, MainWindow):
+        MainWindow.setObjectName("MainWindow")
+        MainWindow.resize(800, 600)
+
+
+        self.centralwidget = QtWidgets.QWidget(MainWindow)
+        self.centralwidget.setObjectName("centralwidget")
+        self.verticalLayout = QtWidgets.QVBoxLayout(self.centralwidget)
+        self.verticalLayout.setObjectName("verticalLayout")
+        self.top_bar = QtWidgets.QFrame(self.centralwidget)
+        self.top_bar.setMaximumSize(QtCore.QSize(16777215, 40))
+        self.top_bar.setStyleSheet("background-color: #2c313c;")
+        self.top_bar.setFrameShape(QtWidgets.QFrame.Shape.NoFrame)
+        self.top_bar.setFrameShadow(QtWidgets.QFrame.Shadow.Raised)
+        self.top_bar.setObjectName("top_bar")
+        self.horizontalLayout = QtWidgets.QHBoxLayout(self.top_bar)
+        self.horizontalLayout.setContentsMargins(0, 0, 0, 0)
+        self.horizontalLayout.setSpacing(0)
+        self.horizontalLayout.setObjectName("horizontalLayout")
+
+        #TITLE LABEL
+        self.title_label = QtWidgets.QLabel(self.top_bar)
+        font = QtGui.QFont()
+        font.setPointSize(10)
+        font.setBold(True)
+        self.title_label.setFont(font)
+        self.title_label.setStyleSheet("color: white;")
+        self.title_label.setObjectName("title_label")
+        self.horizontalLayout.addWidget(self.title_label)
+        self.minimize_button = QtWidgets.QPushButton(self.top_bar)
+        self.minimize_button.setMaximumSize(QtCore.QSize(30, 30))
+        self.minimize_button.setStyleSheet("QPushButton {\n"
+        "    background-color: #2c313c;\n"
+        "    border: none;\n"
+        "    color: white;\n"
+        "}\n"
+        "\n"
+        "QPushButton:hover {\n"
+        "    background-color: #495057;\n"
+        "}\n"
+        "\n"
+        "QPushButton:pressed {\n"
+        "    background-color: #6c757d;\n"
+        "}")
+        self.minimize_button.setObjectName("minimize_button")
+        self.horizontalLayout.addWidget(self.minimize_button)
+        self.close_button = QtWidgets.QPushButton(self.top_bar)
+        self.close_button.setMaximumSize(QtCore.QSize(30, 30))
+        self.close_button.setStyleSheet("QPushButton {\n"
+        "    background-color: #2c313c;\n"
+        "    border: none;\n"
+        "    color: white;\n"
+        "}\n"
+        "\n"
+        "QPushButton:hover {\n"
+        "    background-color: #dc3545;\n"
+        "}\n"
+        "\n"
+        "QPushButton:pressed {\n"
+        "    background-color: #c82333;\n"
+        "}")
+        self.close_button.setObjectName("close_button")
+        self.horizontalLayout.addWidget(self.close_button)
+        self.verticalLayout.addWidget(self.top_bar)
+        self.content_area = QtWidgets.QFrame(self.centralwidget)
+        self.content_area.setStyleSheet("background-color: #212529;")
+        self.content_area.setFrameShape(QtWidgets.QFrame.Shape.StyledPanel)
+        self.content_area.setFrameShadow(QtWidgets.QFrame.Shadow.Raised)
+        self.content_area.setObjectName("content_area")
+        self.verticalLayout_2 = QtWidgets.QVBoxLayout(self.content_area)
+        self.verticalLayout_2.setObjectName("verticalLayout_2")
+        self.model_path_layout = QtWidgets.QHBoxLayout()
+        self.model_path_layout.setObjectName("model_path_layout")
+        self.model_path_label = QtWidgets.QLabel(self.content_area)
+        font = QtGui.QFont()
+        font.setPointSize(10)
+        self.model_path_label.setFont(font)
+        self.model_path_label.setStyleSheet("color: white;")
+        self.model_path_label.setObjectName("model_path_label")
+        self.model_path_layout.addWidget(self.model_path_label)
+        self.model_path_line_edit = QtWidgets.QLineEdit(self.content_area)
+        self.model_path_line_edit.setStyleSheet("background-color: #495057;\n"
+        "color: white;\n"
+        "border-radius: 8px;\n"
+        "padding: 5px;")
+        self.model_path_line_edit.setObjectName("model_path_line_edit")
+        self.model_path_layout.addWidget(self.model_path_line_edit)
+        self.model_browse_button = QtWidgets.QPushButton(self.content_area)
+        self.model_browse_button.setStyleSheet("QPushButton {\n"
+        "    background-color: #495057;\n"
+        "    color: white;\n"
+        "    border-radius: 8px;\n"
+        "    padding: 5px;\n"
+        "}\n"
+        "\n"
+        "QPushButton:hover {\n"
+        "    background-color: #6c757d;\n"
+        "}\n"
+        "\n"
+        "QPushButton:pressed {\n"
+        "    background-color: #343a40;\n"
+        "}")
+        self.model_browse_button.setObjectName("model_browse_button")
+        self.model_path_layout.addWidget(self.model_browse_button)
+        self.verticalLayout_2.addLayout(self.model_path_layout)
+        self.settings_layout = QtWidgets.QGridLayout()
+        self.settings_layout.setObjectName("settings_layout")
+
+
+
+        ############
+        # BATCH SIZE/ CTX
+        ############
+
+        self.batch_size_label = QtWidgets.QLabel(self.content_area)
+        font = QtGui.QFont()
+        font.setPointSize(10)
+        self.batch_size_label.setFont(font)
+        self.batch_size_label.setStyleSheet("color: white;")
+        self.batch_size_label.setObjectName("batch_size_label")
+        self.settings_layout.addWidget(self.batch_size_label, 0, 0, 1, 1)
+
+        self.batch_size_slider = QtWidgets.QSlider(self.content_area)
+        self.batch_size_slider.setStyleSheet("QSlider::groove:horizontal {\n"
+        "    background-color: #495057;\n"
+        "    height: 10px;\n"
+        "}\n"
+        "\n"
+        "QSlider::handle:horizontal {\n"
+        "    background-color: white;\n"
+        "    width: 20px;\n"
+        "    border-radius: 5px;\n"
+        "    margin: -5px 0;\n"
+        "}")
+        self.batch_size_slider.setOrientation(QtCore.Qt.Orientation.Horizontal)
+        self.batch_size_slider.setMinimum(0)
+        self.batch_size_slider.setMaximum(4)
+        self.batch_size_slider.setTickPosition(QtWidgets.QSlider.TickPosition.TicksBelow)
+        self.batch_size_slider.setTickInterval(1)
+        self.batch_size_values = [64, 128, 256, 512, 1024]
+        self.batch_size_slider.valueChanged.connect(self.update_batch_size_label)
+        self.batch_size_slider.setProperty("value", 3)
+        self.settings_layout.addWidget(self.batch_size_slider, 0, 1, 1, 3)
+
+        self.ctx_size_label = QtWidgets.QLabel(self.content_area)
+        font = QtGui.QFont()
+        font.setPointSize(10)
+        self.ctx_size_label.setFont(font)
+        self.ctx_size_label.setStyleSheet("color: white;")
+        self.ctx_size_label.setObjectName("ctx_size_label")
+        self.settings_layout.addWidget(self.ctx_size_label, 1, 0, 1, 3)
+
+        self.ctx_size_slider = QtWidgets.QSlider(self.content_area)
+        self.ctx_size_slider.setStyleSheet("QSlider::groove:horizontal {\n"
+        "    background-color: #495057;\n"
+        "    height: 10px;\n"
+        "}\n"
+        "\n"
+        "QSlider::handle:horizontal {\n"
+        "    background-color: white;\n"
+        "    width: 20px;\n"
+        "    border-radius: 5px;\n"
+        "    margin: -5px 0;\n"
+        "}")
+        self.ctx_size_slider.setOrientation(QtCore.Qt.Orientation.Horizontal)
+        self.ctx_size_slider.setMinimum(0)
+        self.ctx_size_slider.setMaximum(64)
+        
+        self.ctx_size_slider.setTickPosition(QtWidgets.QSlider.TickPosition.TicksBelow)
+        self.ctx_size_slider.setTickInterval(1)
+        self.ctx_size_values = [1024 * (i) for i in range(65)]
+        self.ctx_size_slider.valueChanged.connect(self.update_ctx_size_label)
+        self.ctx_size_slider.setProperty("value", 4)
+        self.settings_layout.addWidget(self.ctx_size_slider, 1, 1, 1, 3)
+
+        ############
+        # UI THREADS / LAYERS
+        ############
+
+        # GPU OFFLOAD
+        self.layers_offload_label = QtWidgets.QLabel(self.content_area)
+        font = QtGui.QFont()
+        font.setPointSize(10)
+        self.layers_offload_label.setFont(font)
+        self.layers_offload_label.setStyleSheet("color: white;")
+        self.layers_offload_label.setObjectName("layers_offload_label")
+        self.settings_layout.addWidget(self.layers_offload_label, 2, 0, 1, 1)
+        self.layers_offload_spin_box = QtWidgets.QSpinBox(self.content_area)
+        self.layers_offload_spin_box.setStyleSheet("background-color: #495057;\n"
+        "color: white;\n"
+        "border-radius: 8px;\n"
+        "padding: 5px;")
+        self.layers_offload_spin_box.setMinimum(0)
+        self.layers_offload_spin_box.setMaximum(200)
+        self.layers_offload_spin_box.setProperty("value", 0)
+        self.layers_offload_spin_box.setObjectName("layers_offload_spin_box")
+        self.settings_layout.addWidget(self.layers_offload_spin_box, 2, 1, 1, 1)
+
+
+        # THREADS
+        self.threads_label = QtWidgets.QLabel(self.content_area)
+        font = QtGui.QFont()
+        font.setPointSize(10)
+        self.threads_label.setFont(font)
+        self.threads_label.setStyleSheet("color: white;")
+        self.threads_label.setObjectName("threads_label")
+        self.settings_layout.addWidget(self.threads_label, 2, 2, 1, 1)
+
+        self.threads_spin_box = QtWidgets.QSpinBox(self.content_area)
+        self.threads_spin_box.setStyleSheet("background-color: #495057;\n"
+        "color: white;\n"
+        "border-radius: 8px;\n"
+        "padding: 5px;")
+        self.threads_spin_box.setMinimum(0)
+        self.threads_spin_box.setMaximum(os.cpu_count())
+        self.threads_spin_box.setProperty("value", int(os.cpu_count()/2))
+        self.threads_spin_box.setObjectName("threads_spin_box")
+        self.settings_layout.addWidget(self.threads_spin_box, 2, 3, 1, 1)
+
+
+
+
+        ###
+        self.verticalLayout_2.addLayout(self.settings_layout)
+        self.advanced_options_layout = QtWidgets.QGridLayout()
+        self.advanced_options_layout.setObjectName("advanced_options_layout")
+        ###
+
+        
+
+        
+        
+        ############
+        # UI MOE
+        ############
+        self.moe_checkbox = QToggle()
+        self.moe_checkbox.setFixedHeight(20)
+        self.moe_checkbox.setDuration(250)
+        self.moe_checkbox.setStyleSheet("QToggle{"
+                            "qproperty-bg_color:#495057;"
+                            "qproperty-circle_color:#FFF;"
+                            "qproperty-active_color:#0066ff;"
+                            "qproperty-disabled_color:#383838;"
+                            "qproperty-text_color:#FFF;}")
+
+        self.moe_checkbox.setObjectName("moe_checkbox")
+        self.advanced_options_layout.addWidget(self.moe_checkbox, 0, 0, 1, 1)
+
+
+
+        self.moe_experts_label = QtWidgets.QLabel(self.content_area)
+        font = QtGui.QFont()
+        font.setPointSize(10)
+        self.moe_experts_label.setFont(font)
+        self.moe_experts_label.setStyleSheet("color: white;")
+        self.moe_experts_label.setObjectName("moe_experts_label")
+        self.advanced_options_layout.addWidget(self.moe_experts_label, 0, 2, 1, 1)
+        self.moe_experts_spin_box = QtWidgets.QSpinBox(self.content_area)
+        self.moe_experts_spin_box.setStyleSheet("background-color: #495057;\n"
+        "color: white;\n"
+        "border-radius: 8px;\n"
+        "padding: 5px;")
+        self.moe_experts_spin_box.setMinimum(1)
+        self.moe_experts_spin_box.setMaximum(32)
+        self.moe_experts_spin_box.setProperty("value", 2)
+        self.moe_experts_spin_box.setObjectName("moe_experts_spin_box")
+        self.advanced_options_layout.addWidget(self.moe_experts_spin_box, 0, 3, 1, 1)
+
+        ############
+        # UI ROPE FREQ BASE
+        ############
+        # CUSTOM ROPE FREQ BASE CHECKBOX
+        self.rope_freq_base_checkbox = QToggle()
+        self.rope_freq_base_checkbox.setFixedHeight(20)
+        self.rope_freq_base_checkbox.setDuration(250)
+        self.rope_freq_base_checkbox.setStyleSheet("QToggle{"
+                            "qproperty-bg_color:#495057;"
+                            "qproperty-circle_color:#FFF;"
+                            "qproperty-active_color:#0066ff;"
+                            "qproperty-disabled_color:#383838;"
+                            "qproperty-text_color:#FFF;}")
+        self.rope_freq_base_checkbox.setObjectName("rope_freq_base_checkbox")
+        self.advanced_options_layout.addWidget(self.rope_freq_base_checkbox, 1, 0, 1, 1)
+
+        # CUSTOM ROPE FREQ BASE LABEL
+        self.rope_freq_base_label = QtWidgets.QLabel(self.content_area)
+        font = QtGui.QFont()
+        font.setPointSize(10)
+        self.rope_freq_base_label.setFont(font)
+        self.rope_freq_base_label.setStyleSheet("color: white;")
+        self.rope_freq_base_label.setObjectName("rope_freq_base_label")
+        self.advanced_options_layout.addWidget(self.rope_freq_base_label, 1, 2, 1, 1)
+        self.rope_freq_base_spin_box = QtWidgets.QSpinBox(self.content_area)
+        self.rope_freq_base_spin_box.setStyleSheet("background-color: #495057;\n"
+        "color: white;\n"
+        "border-radius: 8px;\n"
+        "padding: 5px;")
+        self.rope_freq_base_spin_box.setMinimum(1)
+        self.rope_freq_base_spin_box.setMaximum(1000)
+        self.rope_freq_base_spin_box.setProperty("value", 1)
+        self.rope_freq_base_spin_box.setObjectName("rope_freq_base_spin_box")
+        self.advanced_options_layout.addWidget(self.rope_freq_base_spin_box, 1, 3, 1, 1)
+
+
+
+        ############
+        # UI ADDITIONAL
+        ############
+
+        # FLASH ATTENTION CHECKBOX
+        self.flash_attention_checkbox = QToggle()
+        self.flash_attention_checkbox.setFixedHeight(20)
+        self.flash_attention_checkbox.setDuration(250)
+        self.flash_attention_checkbox.setStyleSheet("QToggle{"
+                            "qproperty-bg_color:#495057;"
+                            "qproperty-circle_color:#FFF;"
+                            "qproperty-active_color:#0066ff;"
+                            "qproperty-disabled_color:#383838;"
+                            "qproperty-text_color:#FFF;}")
+
+        self.flash_attention_checkbox.setObjectName("flash_attention_checkbox")
+        self.advanced_options_layout.addWidget(self.flash_attention_checkbox, 2, 3, 1, 1)
+
+        # MLOCK CHECKBOX
+        self.mlock_checkbox = QToggle()
+        self.mlock_checkbox.setFixedHeight(20)
+        self.mlock_checkbox.setDuration(250)
+        self.mlock_checkbox.setStyleSheet("QToggle{"
+                            "qproperty-bg_color:#495057;"
+                            "qproperty-circle_color:#FFF;"
+                            "qproperty-active_color:#0066ff;"
+                            "qproperty-disabled_color:#383838;"
+                            "qproperty-text_color:#FFF;}")
+        self.mlock_checkbox.setObjectName("mlock_checkbox")
+        self.advanced_options_layout.addWidget(self.mlock_checkbox, 2, 0, 1, 1)
+
+        # NO MMAP CHECKBOX
+        self.no_mmap_checkbox = QToggle()
+        self.no_mmap_checkbox.setFixedHeight(20)
+        self.no_mmap_checkbox.setDuration(250)
+        self.no_mmap_checkbox.setStyleSheet("QToggle{"
+                            "qproperty-bg_color:#495057;"
+                            "qproperty-circle_color:#FFF;"
+                            "qproperty-active_color:#0066ff;"
+                            "qproperty-disabled_color:#383838;"
+                            "qproperty-text_color:#FFF;}")
+
+        self.no_mmap_checkbox.setObjectName("no_mmap_checkbox")
+        self.advanced_options_layout.addWidget(self.no_mmap_checkbox, 2, 1, 1, 1)
+
+        # NO KV OFFLOAD CHECKBOX
+        self.no_kv_offload_checkbox = QToggle()
+        self.no_kv_offload_checkbox.setFixedHeight(20)
+        self.no_kv_offload_checkbox.setDuration(250)
+        self.no_kv_offload_checkbox.setStyleSheet("QToggle{"
+                            "qproperty-bg_color:#495057;"
+                            "qproperty-circle_color:#FFF;"
+                            "qproperty-active_color:#0066ff;"
+                            "qproperty-disabled_color:#383838;"
+                            "qproperty-text_color:#FFF;}")
+
+        self.no_kv_offload_checkbox.setObjectName("no_kv_offload_checkbox")
+        self.advanced_options_layout.addWidget(self.no_kv_offload_checkbox, 2, 2, 1, 1)
+
+
+
+
+
+
+
+
+
+
+
+
+        ##################################
+        # DOWN BUTTONS
+        ##################################
+        self.verticalLayout_2.addLayout(self.advanced_options_layout)
+        self.run_server_button = QtWidgets.QPushButton(self.content_area)
+        self.run_server_button.setStyleSheet("QPushButton {\n"
+        "    background-color: #0066ff;\n"
+        "    color: white;\n"
+        "    padding: 10px;\n"
+        "    border-radius: 8px;\n"
+        "    font-size: 16px;\n"
+        "}\n"
+        "\n"
+        "QPushButton:hover {\n"
+        "    background-color: #1774ff;\n"
+
+
+        "}\n"
+        "\n"
+        "QPushButton:pressed {\n"
+        "    background-color: #0049b8;\n"
+        "}")
+        self.run_server_button.setObjectName("run_server_button")
+        self.verticalLayout_2.addWidget(self.run_server_button)
+        self.config_layout = QtWidgets.QHBoxLayout()
+        self.config_layout.setObjectName("config_layout")
+        self.save_config_button = QtWidgets.QPushButton(self.content_area)
+        self.save_config_button.setStyleSheet("QPushButton {\n"
+        "    background-color: #2e82ff;\n"
+        "    color: white;\n"
+        "    border-radius: 8px;\n"
+        "    padding: 5px;\n"
+        "}\n"
+        "\n"
+        "QPushButton:hover {\n"
+        "    background-color: #428eff;\n"
+        "}\n"
+        "\n"
+        "QPushButton:pressed {\n"
+        "    background-color: #1e6ce3;\n"
+        "}")
+        self.save_config_button.setObjectName("save_config_button")
+        self.config_layout.addWidget(self.save_config_button)
+        self.load_config_button = QtWidgets.QPushButton(self.content_area)
+        self.load_config_button.setStyleSheet("QPushButton {\n"
+        "    background-color: #2e82ff;\n"
+        "    color: white;\n"
+        "    border-radius: 8px;\n"
+        "    padding: 5px;\n"
+        "}\n"
+        "\n"
+        "QPushButton:hover {\n"
+        "    background-color: #428eff;\n"
+        "}\n"
+        "\n"
+        "QPushButton:pressed {\n"
+        "    background-color: #1e6ce3;\n"
+        "}")
+        self.load_config_button.setObjectName("load_config_button")
+        self.config_layout.addWidget(self.load_config_button)
+        self.verticalLayout_2.addLayout(self.config_layout)
+        self.verticalLayout.addWidget(self.content_area)
+        MainWindow.setCentralWidget(self.centralwidget)
+
+        self.retranslateUi(MainWindow)
+        QtCore.QMetaObject.connectSlotsByName(MainWindow)
+
+