diff --git a/logger/logger.go b/logger/logger.go
index 4815a6ef..7d26dcd0 100644
--- a/logger/logger.go
+++ b/logger/logger.go
@@ -1,24 +1,29 @@
 // Package logger provides logging functionality for the 3x-ui panel with
-// buffered log storage and multiple log levels.
+// dual-backend logging (console/syslog and file) and buffered log storage for web UI.
 package logger
 
 import (
 	"fmt"
 	"os"
 	"path/filepath"
+	"runtime"
 	"time"
 
 	"github.com/mhsanaei/3x-ui/v2/config"
 	"github.com/op/go-logging"
 )
 
+const (
+	maxLogBufferSize = 10240                 // Maximum log entries kept in memory
+	logFileName      = "3xui.log"            // Log file name
+	timeFormat       = "2006/01/02 15:04:05" // Log timestamp format
+)
+
 var (
 	logger  *logging.Logger
 	logFile *os.File
 
-	// addToBuffer appends a log entry into the in-memory ring buffer used for
-	// retrieving recent logs via the web UI. It keeps the buffer bounded to avoid
-	// uncontrolled growth.
+	// logBuffer maintains recent log entries in memory for web UI retrieval
 	logBuffer []struct {
 		time  string
 		level logging.Level
@@ -26,42 +31,58 @@ var (
 	}
 )
 
-func init() {
-	InitLogger(logging.INFO)
-}
-
-// InitLogger initializes the logger backends with the specified logging level.
+// InitLogger initializes dual logging backends: console/syslog and file.
+// Console logging uses the specified level, file logging always uses DEBUG level.
 func InitLogger(level logging.Level) {
 	newLogger := logging.MustGetLogger("x-ui")
 	backends := make([]logging.Backend, 0, 2)
 
-	if defaultBackend := initDefaultBackend(); defaultBackend != nil {
-		backends = append(backends, defaultBackend)
+	// Console/syslog backend with configurable level
+	if consoleBackend := initDefaultBackend(); consoleBackend != nil {
+		leveledBackend := logging.AddModuleLevel(consoleBackend)
+		leveledBackend.SetLevel(level, "x-ui")
+		backends = append(backends, leveledBackend)
 	}
+
+	// File backend with DEBUG level for comprehensive logging
 	if fileBackend := initFileBackend(); fileBackend != nil {
-		backends = append(backends, fileBackend)
+		leveledBackend := logging.AddModuleLevel(fileBackend)
+		leveledBackend.SetLevel(logging.DEBUG, "x-ui")
+		backends = append(backends, leveledBackend)
 	}
 
 	multiBackend := logging.MultiLogger(backends...)
-	multiBackend.SetLevel(level, "x-ui")
-
 	newLogger.SetBackend(multiBackend)
 	logger = newLogger
 }
 
+// initDefaultBackend creates the console/syslog logging backend.
+// Windows: Uses stderr directly (no syslog support)
+// Unix-like: Attempts syslog, falls back to stderr
 func initDefaultBackend() logging.Backend {
-	backendSyslog, err := logging.NewSyslogBackend("")
-	var backend logging.Backend = backendSyslog
+	var backend logging.Backend
 	includeTime := false
-	if err != nil {
-		fmt.Fprintf(os.Stderr, "syslog backend disabled: %v\n", err)
-		ppid := os.Getppid()
+
+	if runtime.GOOS == "windows" {
+		// Windows: Use stderr directly (no syslog support)
 		backend = logging.NewLogBackend(os.Stderr, "", 0)
-		includeTime = ppid > 0
+		includeTime = true
+	} else {
+		// Unix-like: Try syslog, fallback to stderr
+		if syslogBackend, err := logging.NewSyslogBackend(""); err != nil {
+			fmt.Fprintf(os.Stderr, "syslog backend disabled: %v\n", err)
+			backend = logging.NewLogBackend(os.Stderr, "", 0)
+			includeTime = os.Getppid() > 0
+		} else {
+			backend = syslogBackend
+		}
 	}
+
 	return logging.NewBackendFormatter(backend, newFormatter(includeTime))
 }
 
+// initFileBackend creates the file logging backend.
+// Creates log directory and truncates log file on startup for fresh logs.
 func initFileBackend() logging.Backend {
 	logDir := config.GetLogFolder()
 	if err := os.MkdirAll(logDir, 0o750); err != nil {
@@ -69,13 +90,14 @@ func initFileBackend() logging.Backend {
 		return nil
 	}
 
-	logPath := filepath.Join(logDir, "3xui.log")
-	file, err := os.OpenFile(logPath, os.O_CREATE|os.O_WRONLY|os.O_APPEND, 0o660)
+	logPath := filepath.Join(logDir, logFileName)
+	file, err := os.OpenFile(logPath, os.O_CREATE|os.O_WRONLY|os.O_TRUNC, 0o660)
 	if err != nil {
 		fmt.Fprintf(os.Stderr, "failed to open log file %s: %v\n", logPath, err)
 		return nil
 	}
 
+	// Close previous log file if exists
 	if logFile != nil {
 		_ = logFile.Close()
 	}
@@ -85,11 +107,22 @@ func initFileBackend() logging.Backend {
 	return logging.NewBackendFormatter(backend, newFormatter(true))
 }
 
+// newFormatter creates a log formatter with optional timestamp.
 func newFormatter(withTime bool) logging.Formatter {
+	format := `%{level} - %{message}`
 	if withTime {
-		return logging.MustStringFormatter(`%{time:2006/01/02 15:04:05} %{level} - %{message}`)
+		format = `%{time:` + timeFormat + `} %{level} - %{message}`
+	}
+	return logging.MustStringFormatter(format)
+}
+
+// CloseLogger closes the log file and cleans up resources.
+// Should be called during application shutdown.
+func CloseLogger() {
+	if logFile != nil {
+		_ = logFile.Close()
+		logFile = nil
 	}
-	return logging.MustStringFormatter(`%{level} - %{message}`)
 }
 
 // Debug logs a debug message and adds it to the log buffer.
@@ -152,9 +185,10 @@ func Errorf(format string, args ...any) {
 	addToBuffer("ERROR", fmt.Sprintf(format, args...))
 }
 
+// addToBuffer adds a log entry to the in-memory ring buffer for web UI retrieval.
 func addToBuffer(level string, newLog string) {
 	t := time.Now()
-	if len(logBuffer) >= 10240 {
+	if len(logBuffer) >= maxLogBufferSize {
 		logBuffer = logBuffer[1:]
 	}
 
@@ -164,7 +198,7 @@ func addToBuffer(level string, newLog string) {
 		level logging.Level
 		log   string
 	}{
-		time:  t.Format("2006/01/02 15:04:05"),
+		time:  t.Format(timeFormat),
 		level: logLevel,
 		log:   newLog,
 	})
diff --git a/sub/sub.go b/sub/sub.go
index 1a1a7d9e..0605c8b9 100644
--- a/sub/sub.go
+++ b/sub/sub.go
@@ -103,7 +103,7 @@ func (s *Server) initRouter() (*gin.Engine, error) {
 	if basePath != "/" && !strings.HasSuffix(basePath, "/") {
 		basePath += "/"
 	}
-	logger.Debug("sub: Setting base_path to:", basePath)
+	// logger.Debug("sub: Setting base_path to:", basePath)
 	engine.Use(func(c *gin.Context) {
 		c.Set("base_path", basePath)
 	})