diff --git a/.github/workflows/slurm-localhost.yml b/.github/workflows/slurm-localhost.yml
new file mode 100644
index 0000000..3750d22
--- /dev/null
+++ b/.github/workflows/slurm-localhost.yml
@@ -0,0 +1,442 @@
+name: SLURM Localhost Test
+
+on:
+  push:
+    branches: [ main, develop ]
+  pull_request:
+    branches: [ main, develop ]
+  workflow_dispatch:
+
+jobs:
+  slurm-localhost-test:
+    name: SLURM localhost on Ubuntu with Python ${{ matrix.python-version }}
+    runs-on: ubuntu-latest
+    strategy:
+      fail-fast: false
+      matrix:
+        python-version: ['3.11']
+
+    env:
+      FZ_LOG_LEVEL: DEBUG
+
+    steps:
+    - name: Checkout code
+      uses: actions/checkout@v4
+
+    - name: Set up Python ${{ matrix.python-version }}
+      uses: actions/setup-python@v5
+      with:
+        python-version: ${{ matrix.python-version }}
+
+    - name: Install Python dependencies
+      run: |
+        python -m pip install --upgrade pip
+        pip install -e .
+        pip install pytest
+        pip install pandas
+
+    - name: Install SLURM
+      run: |
+        echo "Installing SLURM packages..."
+        sudo apt-get update
+        sudo apt-get install -y slurm-wlm slurm-wlm-doc munge
+        echo "✓ SLURM packages installed"
+
+        # Verify installation
+        sinfo --version || true
+        srun --version || true
+
+    - name: Configure Munge (SLURM authentication)
+      run: |
+        echo "Configuring Munge authentication..."
+
+        # Create munge key
+        sudo mkdir -p /etc/munge
+        sudo dd if=/dev/urandom bs=1 count=1024 > /tmp/munge.key
+        sudo mv /tmp/munge.key /etc/munge/munge.key
+        sudo chown munge:munge /etc/munge/munge.key
+        sudo chmod 400 /etc/munge/munge.key
+
+        # Set up munge directories
+        sudo mkdir -p /var/run/munge
+        sudo chown munge:munge /var/run/munge
+        sudo mkdir -p /var/log/munge
+        sudo chown munge:munge /var/log/munge
+
+        # Start munge
+        sudo systemctl enable munge
+        sudo systemctl start munge
+
+        # Verify munge is running
+        sudo systemctl status munge --no-pager
+        echo "✓ Munge authentication configured"
+
+    - name: Configure SLURM
+      run: |
+        echo "Configuring SLURM..."
+
+        # Get hostname
+        HOSTNAME=$(hostname)
+        echo "Hostname: $HOSTNAME"
+
+        # Create SLURM configuration
+        sudo mkdir -p /etc/slurm
+        sudo tee /etc/slurm/slurm.conf > /dev/null <<EOF
+        # SLURM Configuration for CI Testing
+        ClusterName=fz-test-cluster
+        SlurmctldHost=$HOSTNAME
+        MpiDefault=none
+        ProctrackType=proctrack/linuxproc
+        ReturnToService=2
+        SlurmctldPidFile=/var/run/slurm/slurmctld.pid
+        SlurmdPidFile=/var/run/slurm/slurmd.pid
+        SlurmdSpoolDir=/var/spool/slurmd
+        SlurmUser=slurm
+        StateSaveLocation=/var/spool/slurmctld
+        SwitchType=switch/none
+        TaskPlugin=task/none
+
+        # TIMERS
+        InactiveLimit=0
+        KillWait=30
+        MinJobAge=300
+        SlurmctldTimeout=120
+        SlurmdTimeout=300
+        Waittime=0
+
+        # SCHEDULING
+        SchedulerType=sched/backfill
+        SelectType=select/cons_tres
+        SelectTypeParameters=CR_Core
+
+        # LOGGING
+        SlurmctldDebug=info
+        SlurmctldLogFile=/var/log/slurm/slurmctld.log
+        SlurmdDebug=info
+        SlurmdLogFile=/var/log/slurm/slurmd.log
+
+        # COMPUTE NODES
+        NodeName=$HOSTNAME CPUs=2 State=UNKNOWN
+        PartitionName=debug Nodes=$HOSTNAME Default=YES MaxTime=INFINITE State=UP
+        PartitionName=compute Nodes=$HOSTNAME MaxTime=INFINITE State=UP
+        EOF
+
+        echo "✓ SLURM configuration created"
+        cat /etc/slurm/slurm.conf
+
+    - name: Setup SLURM directories and permissions
+      run: |
+        echo "Setting up SLURM directories..."
+
+        # Create necessary directories
+        sudo mkdir -p /var/spool/slurmctld
+        sudo mkdir -p /var/spool/slurmd
+        sudo mkdir -p /var/log/slurm
+        sudo mkdir -p /var/run/slurm
+
+        # Set ownership
+        sudo chown -R slurm:slurm /var/spool/slurmctld
+        sudo chown -R slurm:slurm /var/spool/slurmd
+        sudo chown -R slurm:slurm /var/log/slurm
+        sudo chown -R slurm:slurm /var/run/slurm
+        sudo chown -R slurm:slurm /etc/slurm
+
+        echo "✓ SLURM directories configured"
+
+    - name: Start SLURM controller
+      run: |
+        echo "Starting SLURM controller (slurmctld)..."
+        sudo systemctl enable slurmctld
+        sudo systemctl start slurmctld
+        sleep 3
+        sudo systemctl status slurmctld --no-pager || true
+        echo "✓ SLURM controller started"
+
+    - name: Start SLURM compute daemon
+      run: |
+        echo "Starting SLURM compute daemon (slurmd)..."
+        sudo systemctl enable slurmd
+        sudo systemctl start slurmd
+        sleep 3
+        sudo systemctl status slurmd --no-pager || true
+        echo "✓ SLURM compute daemon started"
+
+    - name: Verify SLURM is operational
+      run: |
+        echo "Verifying SLURM cluster status..."
+
+        # Wait for node to become ready
+        for i in {1..30}; do
+          sinfo && break || sleep 2
+        done
+
+        # Show cluster info
+        echo "=== SLURM Info ==="
+        sinfo -Nel || true
+
+        echo "=== SLURM Partitions ==="
+        sinfo -s || true
+
+        echo "=== SLURM Configuration ==="
+        scontrol show config | head -20 || true
+
+        # Test basic srun
+        echo "=== Testing basic srun command ==="
+        srun --partition=debug echo "SLURM is working!" || {
+          echo "ERROR: srun failed"
+          sudo journalctl -u slurmctld -n 50 --no-pager
+          sudo journalctl -u slurmd -n 50 --no-pager
+          exit 1
+        }
+
+        echo "✓ SLURM is fully operational"
+
+    - name: Create test script
+      run: |
+        echo "Creating test calculation script..."
+
+        # Create script in user home directory (accessible to SLURM jobs)
+        mkdir -p $HOME/fz_test
+        cat > $HOME/fz_test/slurm_calc.sh <<'EOF'
+        #!/bin/bash
+        # Simple test calculation script for SLURM
+        set -e
+
+        # Read input file (passed as argument or default to current dir)
+        INPUT_FILE="${1:-input.txt}"
+
+        echo "Processing input: $INPUT_FILE"
+        if [ -f "$INPUT_FILE" ]; then
+          cat "$INPUT_FILE"
+        fi
+
+        # Create output
+        echo "SLURM calculation completed successfully" > output.txt
+        echo "Hostname: $(hostname)" >> output.txt
+        echo "Date: $(date)" >> output.txt
+        echo "PWD: $(pwd)" >> output.txt
+        echo "Job ID: ${SLURM_JOB_ID:-none}" >> output.txt
+        echo "Partition: ${SLURM_JOB_PARTITION:-none}" >> output.txt
+
+        # If input has variable x, square it
+        if [ -f "$INPUT_FILE" ] && grep -q "x = " "$INPUT_FILE" 2>/dev/null; then
+          x=$(grep "x = " "$INPUT_FILE" | awk '{print $3}')
+          result=$((x * x))
+          echo "result = $result" >> output.txt
+        fi
+
+        echo "Output created:"
+        cat output.txt
+        EOF
+
+        chmod +x $HOME/fz_test/slurm_calc.sh
+        echo "✓ Test script created at $HOME/fz_test/slurm_calc.sh"
+
+    - name: Test SLURM calculator - Sequential execution
+      run: |
+        echo "Testing FZ with SLURM calculator (sequential)..."
+        SCRIPT_PATH="$HOME/fz_test/slurm_calc.sh"
+        echo "Using script: $SCRIPT_PATH"
+
+        python3 << PYTHON
+        import tempfile
+        import os
+        from pathlib import Path
+        from fz import fzr
+
+        print("=" * 60)
+        print("Test 1: Sequential SLURM execution (single case)")
+        print("=" * 60)
+
+        script_path = os.path.expanduser("~/fz_test/slurm_calc.sh")
+        print(f"Script path: {script_path}")
+
+        with tempfile.TemporaryDirectory() as tmpdir:
+            # Create input template
+            input_file = Path(tmpdir) / "input.txt"
+            input_file.write_text("x = \${x}\\n")
+
+            # Define model
+            model = {
+                "output": {
+                    "result": "grep 'result = ' output.txt | awk '{print \$3}'"
+                }
+            }
+
+            # Run calculation with SLURM (single scalar value)
+            calculator_uri = f"slurm://debug/bash {script_path}"
+            print(f"Calculator URI: {calculator_uri}")
+
+            results = fzr(
+                str(input_file),
+                {"x": 3},  # Test with scalar value instead of list
+                model,
+                calculators=calculator_uri,
+                results_dir=str(Path(tmpdir) / "results")
+            )
+
+            print(f"\\nResults: {results}")
+
+            # Verify results (scalar input returns dict with list values)
+            if hasattr(results, 'to_dict'):
+                # If pandas DataFrame, get first row
+                results_dict = results.to_dict('records')[0]
+            elif isinstance(results, dict):
+                # Direct dict - check if values are lists
+                if isinstance(results.get('x'), list):
+                    # Dict with list values - extract first element
+                    results_dict = {k: v[0] if isinstance(v, list) else v for k, v in results.items()}
+                else:
+                    results_dict = results
+            elif isinstance(results, list):
+                # List of dicts - get first element
+                results_dict = results[0]
+            else:
+                results_dict = results
+
+            print(f"\\nExtracted results: {results_dict}")
+            assert results_dict['x'] == 3, f"Expected x=3, got {results_dict['x']}"
+            assert results_dict['result'] == 9 or results_dict['result'] == '9', f"Expected result=9 or '9', got {results_dict['result']}"
+            print("\\n✓ Sequential SLURM test passed!")
+        PYTHON
+
+    - name: Test SLURM calculator - Parallel execution
+      run: |
+        echo "Testing FZ with SLURM calculator (parallel)..."
+
+        python3 << PYTHON
+        import tempfile
+        import os
+        from pathlib import Path
+        from fz import fzr
+
+        print("=" * 60)
+        print("Test 2: Parallel SLURM execution (multiple cases)")
+        print("=" * 60)
+
+        script_path = os.path.expanduser("~/fz_test/slurm_calc.sh")
+
+        with tempfile.TemporaryDirectory() as tmpdir:
+            # Create input template
+            input_file = Path(tmpdir) / "input.txt"
+            input_file.write_text("x = \${x}\\n")
+
+            # Define model
+            model = {
+                "output": {
+                    "result": "grep 'result = ' output.txt | awk '{print \$3}'"
+                }
+            }
+
+            # Run calculation with SLURM (multiple cases)
+            # Use 2 parallel workers (2 SLURM calculators)
+            calculator_uri = f"slurm://debug/bash {script_path}"
+
+            results = fzr(
+                str(input_file),
+                {"x": [1, 2, 3, 4]},
+                model,
+                calculators=[calculator_uri, calculator_uri],
+                results_dir=str(Path(tmpdir) / "results")
+            )
+
+            print(f"\\nResults: {results}")
+
+            # Verify results
+            if hasattr(results, 'to_dict'):
+                results_list = results.to_dict('records')
+            else:
+                results_list = [results] if isinstance(results, dict) else results
+
+            assert len(results_list) == 4, f"Expected 4 results, got {len(results_list)}"
+
+            for r in results_list:
+                x_val = r['x']
+                expected_result = x_val * x_val
+                actual_result = r['result']
+                # Convert both to same type for comparison (result may be int or string)
+                assert str(actual_result) == str(expected_result), f"For x={x_val}, expected result={expected_result}, got {actual_result}"
+
+            print("\\n✓ Parallel SLURM test passed!")
+        PYTHON
+
+    - name: Test SLURM calculator - Multiple partitions
+      run: |
+        echo "Testing FZ with SLURM calculator (multiple partitions)..."
+
+        python3 << PYTHON
+        import tempfile
+        import os
+        from pathlib import Path
+        from fz import fzr
+
+        print("=" * 60)
+        print("Test 3: SLURM with multiple partitions")
+        print("=" * 60)
+
+        script_path = os.path.expanduser("~/fz_test/slurm_calc.sh")
+
+        with tempfile.TemporaryDirectory() as tmpdir:
+            # Create input template
+            input_file = Path(tmpdir) / "input.txt"
+            input_file.write_text("x = \${x}\\n")
+
+            # Define model
+            model = {
+                "output": {
+                    "result": "grep 'result = ' output.txt | awk '{print \$3}'"
+                }
+            }
+
+            # Run calculation with different SLURM partitions
+            results = fzr(
+                str(input_file),
+                {"x": [5, 6]},
+                model,
+                calculators=[
+                    f"slurm://debug/bash {script_path}",
+                    f"slurm://compute/bash {script_path}"
+                ],
+                results_dir=str(Path(tmpdir) / "results")
+            )
+
+            print(f"\\nResults: {results}")
+
+            # Verify results
+            if hasattr(results, 'to_dict'):
+                results_list = results.to_dict('records')
+            else:
+                results_list = [results] if isinstance(results, dict) else results
+
+            assert len(results_list) == 2, f"Expected 2 results, got {len(results_list)}"
+
+            for r in results_list:
+                x_val = r['x']
+                expected_result = x_val * x_val
+                actual_result = r['result']
+                # Convert both to same type for comparison (result may be int or string)
+                assert str(actual_result) == str(expected_result), f"For x={x_val}, expected result={expected_result}, got {actual_result}"
+
+            print("\\n✓ Multiple partition test passed!")
+        PYTHON
+
+    - name: Show SLURM logs on failure
+      if: failure()
+      run: |
+        echo "=== SLURM Controller Logs ==="
+        sudo journalctl -u slurmctld -n 100 --no-pager || true
+
+        echo "=== SLURM Compute Logs ==="
+        sudo journalctl -u slurmd -n 100 --no-pager || true
+
+        echo "=== SLURM Log Files ==="
+        sudo cat /var/log/slurm/slurmctld.log || true
+        sudo cat /var/log/slurm/slurmd.log || true
+
+        echo "=== Munge Logs ==="
+        sudo journalctl -u munge -n 50 --no-pager || true
+
+    - name: Test summary
+      if: always()
+      run: |
+        echo "SLURM localhost connectivity and execution test completed"
diff --git a/CLAUDE.md b/CLAUDE.md
index 6fc328f..21c0438 100644
--- a/CLAUDE.md
+++ b/CLAUDE.md
@@ -78,9 +78,10 @@ The codebase is organized into functional modules (~5700 lines total):
   - Support for default values: `${var~default}`
   - Multi-line function definitions in formulas
 
-- **`fz/runners.py`** (1345 lines) - Calculator execution engines
+- **`fz/runners.py`** (~1900 lines) - Calculator execution engines
   - **Local shell execution** (`sh://`) - runs commands in temporary directories
   - **SSH remote execution** (`ssh://`) - remote HPC/cluster support with file transfer
+  - **SLURM workload manager** (`slurm://`) - local or remote SLURM cluster execution with partition scheduling
   - **Cache calculator** (`cache://`) - reuses previous results by input hash matching
   - Host key validation, authentication handling, timeout management
 
diff --git a/README.md b/README.md
index 4e7ca57..4e840d2 100644
--- a/README.md
+++ b/README.md
@@ -989,6 +989,46 @@ calculators = "ssh://user@server.com:2222/bash /absolutepath/to/calc.sh"
 - Warning for password-based auth
 - Environment variable for auto-accepting host keys: `FZ_SSH_AUTO_ACCEPT_HOSTKEYS=1`
 
+### SLURM Workload Manager
+
+Execute calculations on SLURM clusters (local or remote):
+
+```python
+# Local SLURM execution
+calculators = "slurm://compute/bash script.sh"
+
+# Remote SLURM execution via SSH
+calculators = "slurm://user@cluster.edu:gpu/bash script.sh"
+
+# With custom SSH port
+calculators = "slurm://user@cluster.edu:2222:gpu/bash script.sh"
+
+# Multiple partitions for parallel execution
+calculators = [
+    "slurm://user@hpc.edu:compute/bash calc.sh",
+    "slurm://user@hpc.edu:gpu/bash calc.sh"
+]
+```
+
+**URI Format**: `slurm://[user@host[:port]:]partition/script`
+
+**How it works**:
+1. Local execution: Uses `srun --partition=<partition> <script>` directly
+2. Remote execution: Connects via SSH, transfers files, runs `srun` on remote cluster
+3. Automatically handles SLURM partition scheduling
+4. Supports interrupt handling (Ctrl+C terminates SLURM jobs)
+
+**Features**:
+- Local or remote SLURM execution
+- Automatic file transfer for remote execution (via SFTP)
+- SLURM partition specification
+- Timeout and interrupt handling
+- Compatible with all SLURM schedulers
+
+**Requirements**:
+- Local: SLURM installed (`srun` command available)
+- Remote: SSH access to SLURM cluster + `paramiko` library
+
 ### Cache Calculator
 
 Reuse previous calculation results:
diff --git a/fz/runners.py b/fz/runners.py
index d5244e0..3d4c56d 100644
--- a/fz/runners.py
+++ b/fz/runners.py
@@ -265,6 +265,136 @@ def parse_ssh_uri(ssh_uri: str) -> Tuple[str, int, str, Optional[str], str]:
     return host, port, username, password, command
 
 
+def parse_slurm_uri(slurm_uri: str) -> Tuple[Optional[str], Optional[int], Optional[str], Optional[str], str, str]:
+    """
+    Parse SLURM URI into components
+
+    Args:
+        slurm_uri: SLURM URI in format slurm://[user[:password]@host[:port]:]partition/script
+
+    Returns:
+        Tuple of (host, port, username, password, partition, script)
+        - host will be None for local SLURM execution
+        - port will be None if host is None or not specified
+        - username will be None if host is None or not specified
+        - password will be None if host is None or not specified
+        - partition is the SLURM partition name (required)
+        - script is the script path to execute (required)
+    """
+    # Remove slurm:// prefix
+    if slurm_uri.startswith("slurm://"):
+        uri_part = slurm_uri[8:]
+    else:
+        uri_part = slurm_uri
+
+    # Split to find the partition and script (everything after FIRST /)
+    # Format: [user[:password]@host[:port]:]partition/script
+    if "/" not in uri_part:
+        raise ValueError(
+            f"Invalid SLURM URI format: '{slurm_uri}'. "
+            "Expected format: slurm://[user@host:]partition/script"
+        )
+
+    # Split on FIRST / to separate partition/connection from script
+    # This is important because script may contain / characters in the path
+    first_slash_idx = uri_part.find("/")
+    partition_part = uri_part[:first_slash_idx]
+    script = uri_part[first_slash_idx + 1:]
+
+    if not script:
+        raise ValueError(
+            f"Invalid SLURM URI: script path is required. "
+            "Expected format: slurm://[user@host:]partition/script"
+        )
+
+    # Now parse partition_part to extract optional host and required partition
+    # Format: [user[:password]@host[:port]:]partition
+    host = None
+    port = None
+    username = None
+    password = None
+    partition = partition_part
+
+    # Check if there's a colon that separates host from partition
+    # We need to be careful because:
+    # - user:password@host:port:partition has multiple colons
+    # - host:port:partition has multiple colons
+    # - partition alone has no colons (unless partition name has colons, which is unlikely)
+
+    # Look for @ symbol which indicates user@host format
+    if "@" in partition_part:
+        # Format is user[:password]@host[:port]:partition
+        user_part, rest = partition_part.split("@", 1)
+
+        # Parse user and optional password
+        if ":" in user_part:
+            username, password = user_part.split(":", 1)
+        else:
+            username = user_part
+
+        # Parse host[:port]:partition
+        # Find the last colon which separates host:port from partition
+        if ":" in rest:
+            # Could be host:port:partition or host:partition
+            # We need to find where partition starts
+            # Try to find a pattern: everything before last : is host[:port]
+            last_colon_idx = rest.rfind(":")
+            host_port_part = rest[:last_colon_idx]
+            partition = rest[last_colon_idx + 1:]
+
+            # Parse host[:port]
+            if ":" in host_port_part:
+                host, port_str = host_port_part.split(":", 1)
+                try:
+                    port = int(port_str)
+                except ValueError:
+                    raise ValueError(f"Invalid port number: {port_str}")
+            else:
+                host = host_port_part
+                port = 22  # Default SSH port
+        else:
+            # No colon after @, so it's just user@partition
+            # This means local execution but with username specified (unusual)
+            raise ValueError(
+                f"Invalid SLURM URI format: '{slurm_uri}'. "
+                "If username is provided, host must also be provided. "
+                "Expected format: slurm://user@host:partition/script"
+            )
+    elif ":" in partition_part:
+        # Format might be host:partition or host:port:partition (no user)
+        # Count colons to determine format
+        colons = partition_part.count(":")
+
+        if colons == 1:
+            # host:partition
+            host, partition = partition_part.split(":", 1)
+            port = 22  # Default SSH port
+        elif colons == 2:
+            # host:port:partition
+            parts = partition_part.split(":")
+            host = parts[0]
+            try:
+                port = int(parts[1])
+            except ValueError:
+                raise ValueError(f"Invalid port number: {parts[1]}")
+            partition = parts[2]
+        else:
+            # Too many colons, unclear format
+            raise ValueError(
+                f"Invalid SLURM URI format: '{slurm_uri}'. "
+                "Too many colons. Expected format: slurm://[user@host:]partition/script"
+            )
+    # else: partition_part is just the partition name (local execution)
+
+    if not partition:
+        raise ValueError(
+            f"Invalid SLURM URI: partition is required. "
+            "Expected format: slurm://[user@host:]partition/script"
+        )
+
+    return host, port, username, password, partition, script
+
+
 def _validate_calculator_uri(calculator_uri: str) -> None:
     """
     Validate calculator URI format and scheme
@@ -285,13 +415,13 @@ def _validate_calculator_uri(calculator_uri: str) -> None:
     if "://" not in calculator_uri:
         raise ValueError(
             f"Invalid calculator URI format: '{calculator_uri}'. "
-            "URI must include a scheme (e.g., 'sh://', 'ssh://', 'cache://'). "
+            "URI must include a scheme (e.g., 'sh://', 'ssh://', 'cache://', 'slurm://'). "
             "If using a calculator alias, ensure it exists in .fz/calculators/"
         )
 
     # Extract and validate scheme
     scheme = calculator_uri.split("://", 1)[0].lower()
-    supported_schemes = ["sh", "ssh", "cache"]
+    supported_schemes = ["sh", "ssh", "cache", "slurm"]
 
     if scheme not in supported_schemes:
         raise ValueError(
@@ -306,6 +436,13 @@ def _validate_calculator_uri(calculator_uri: str) -> None:
         except ValueError as e:
             raise ValueError(f"Invalid SSH calculator URI: {e}")
 
+    # Validate SLURM URI format if scheme is slurm
+    if scheme == "slurm":
+        try:
+            parse_slurm_uri(calculator_uri)
+        except ValueError as e:
+            raise ValueError(f"Invalid SLURM calculator URI: {e}")
+
 
 def resolve_calculators(
     calculators: Union[str, List[str], List[Dict]], model_id: str = None
@@ -396,7 +533,7 @@ def run_calculation(
 
     Args:
         working_dir: Directory containing input files
-        calculator_uri: Calculator URI (e.g., "sh://command", "ssh://host/command")
+        calculator_uri: Calculator URI (e.g., "sh://command", "ssh://host/command", "slurm://partition/script")
         model: Model definition dict
         timeout: Timeout in seconds
         original_input_was_dir: Whether original input was a directory
@@ -431,6 +568,12 @@ def run_calculation(
             working_dir, base_uri, model, timeout, input_files_list
         )
 
+    elif base_uri.startswith("slurm://"):
+        # SLURM execution (local or remote)
+        return run_slurm_calculation(
+            working_dir, base_uri, model, timeout, input_files_list
+        )
+
     else:
         # Default to local shell
         return run_local_calculation(
@@ -1108,6 +1251,605 @@ def run_ssh_calculation(
             pass
 
 
+def run_slurm_calculation(
+    working_dir: Path,
+    slurm_uri: str,
+    model: Dict,
+    timeout: int = 300,
+    input_files_list: List[str] = None,
+) -> Dict[str, Any]:
+    """
+    Run calculation via SLURM workload manager
+
+    Args:
+        working_dir: Directory containing input files
+        slurm_uri: SLURM URI (e.g., "slurm://partition/script" or "slurm://user@host:partition/script")
+        model: Model definition dict
+        timeout: Timeout in seconds
+        input_files_list: List of input file names in order (from .fz_hash)
+
+    Returns:
+        Dict containing calculation results and status
+    """
+    # Import here to avoid circular imports
+    from .core import is_interrupted
+
+    # Check for interrupt before starting
+    if is_interrupted():
+        return {
+            "status": "interrupted",
+            "error": "Execution interrupted by user",
+            "command": slurm_uri,
+        }
+
+    start_time = datetime.now()
+    env_info = get_environment_info()
+
+    try:
+        # Parse SLURM URI
+        host, port, username, password, partition, script = parse_slurm_uri(slurm_uri)
+
+        log_info(f"SLURM calculation: partition={partition}, script={script}")
+
+        # Check if this is local or remote SLURM execution
+        if host is None:
+            # Local SLURM execution
+            return _run_local_slurm_calculation(
+                working_dir, partition, script, model, timeout, start_time, env_info, input_files_list
+            )
+        else:
+            # Remote SLURM execution via SSH
+            if not PARAMIKO_AVAILABLE:
+                return {
+                    "status": "error",
+                    "error": "paramiko library not available for remote SLURM. Install with: pip install paramiko",
+                }
+
+            if not username:
+                # Try to get username from environment or use current user
+                username = os.getenv("SSH_USER") or getpass.getuser()
+
+            log_info(f"Remote SLURM: connecting to {username}@{host}:{port or 22}")
+
+            return _run_remote_slurm_calculation(
+                working_dir, host, port or 22, username, password, partition, script,
+                model, timeout, start_time, env_info, input_files_list
+            )
+
+    except Exception as e:
+        return {"status": "error", "error": f"SLURM calculation failed: {str(e)}"}
+
+
+def _run_local_slurm_calculation(
+    working_dir: Path,
+    partition: str,
+    script: str,
+    model: Dict,
+    timeout: int,
+    start_time: datetime,
+    env_info: Dict,
+    input_files_list: List[str] = None,
+) -> Dict[str, Any]:
+    """
+    Run SLURM calculation locally using srun
+
+    Args:
+        working_dir: Directory containing input files
+        partition: SLURM partition name
+        script: Script to execute via srun
+        model: Model definition dict
+        timeout: Timeout in seconds
+        start_time: Calculation start time
+        env_info: Environment information
+        input_files_list: List of input file names in order
+
+    Returns:
+        Dict containing calculation results and status
+    """
+    from .core import is_interrupted, fzo
+
+    # Check for interrupt before starting
+    if is_interrupted():
+        return {
+            "status": "interrupted",
+            "error": "Execution interrupted by user",
+            "command": f"srun --partition={partition} {script}",
+        }
+
+    original_cwd = os.getcwd()
+    process = None
+
+    try:
+        os.chdir(working_dir)
+
+        # Build arguments from input files list
+        input_argument = " ".join(input_files_list) if input_files_list else "."
+
+        # Construct srun command
+        # Use --partition for partition and execute the script
+        full_command = f"srun --partition={partition} {script} {input_argument}"
+
+        log_info(f"Running SLURM command: {full_command}")
+
+        # Prepare output files
+        out_file_path = working_dir / "out.txt"
+        err_file_path = working_dir / "err.txt"
+
+        with open(out_file_path, "w") as out_file, open(err_file_path, "w") as err_file:
+            # Start process with Popen to allow interrupt handling
+            from .shell import run_command
+
+            process = run_command(
+                full_command,
+                shell=True,
+                stdout=out_file,
+                stderr=err_file,
+                cwd=working_dir,
+                use_popen=True,
+            )
+
+            # Poll process and check for interrupts
+            poll_interval = 0.5  # Poll every 500ms
+            elapsed_time = 0.0
+
+            while process.poll() is None:
+                # Check if user requested interrupt
+                if is_interrupted():
+                    log_warning(f"⚠️  Interrupt detected, terminating SLURM job...")
+                    process.terminate()
+                    try:
+                        process.wait(timeout=5)
+                    except subprocess.TimeoutExpired:
+                        log_warning(f"⚠️  Process didn't terminate, killing...")
+                        process.kill()
+                        process.wait()
+                    raise KeyboardInterrupt("SLURM job interrupted by user")
+
+                # Check for timeout
+                if elapsed_time >= timeout:
+                    raise subprocess.TimeoutExpired(full_command, timeout)
+
+                # Sleep briefly before next poll
+                time.sleep(poll_interval)
+                elapsed_time += poll_interval
+
+            result = process
+
+        # Small delay to ensure streams are closed
+        time.sleep(0.01)
+
+        # Create enhanced log file
+        end_time = datetime.now()
+        execution_time = (end_time - start_time).total_seconds()
+
+        log_file_path = working_dir / "log.txt"
+        with open(log_file_path, "w") as log_file:
+            log_file.write(f"Command: {full_command}\n")
+            log_file.write(f"Exit code: {result.returncode}\n")
+            log_file.write(f"SLURM partition: {partition}\n")
+            log_file.write(f"Time start: {start_time.isoformat()}\n")
+            log_file.write(f"Time end: {end_time.isoformat()}\n")
+            log_file.write(f"Execution time: {execution_time:.3f} seconds\n")
+            log_file.write(f"User: {env_info['user']}\n")
+            log_file.write(f"Hostname: {env_info['hostname']}\n")
+            log_file.write(f"Operating system: {env_info['operating_system']}\n")
+            log_file.write(f"Platform: {env_info['platform']}\n")
+            log_file.write(f"Working directory: {working_dir}\n")
+            log_file.write(f"Timestamp: {time.ctime()}\n")
+
+        if result.returncode != 0:
+            # Read stderr for error details
+            stderr_content = ""
+            try:
+                if err_file_path.exists():
+                    with open(err_file_path, "r") as f:
+                        stderr_content = f.read().strip()
+            except Exception:
+                pass
+
+            return {
+                "status": "failed",
+                "exit_code": result.returncode,
+                "error": f"SLURM job failed with exit code {result.returncode}",
+                "stderr": stderr_content,
+                "command": full_command,
+            }
+
+        # Parse output
+        output_results = fzo(working_dir, model)
+
+        # Convert DataFrame to dict if needed
+        if hasattr(output_results, "to_dict"):
+            output_dict = output_results.iloc[0].to_dict()
+        else:
+            output_dict = output_results
+
+        output_dict["status"] = "done"
+        output_dict["calculator"] = f"slurm://{partition}"
+        output_dict["command"] = full_command
+
+        return output_dict
+
+    except subprocess.TimeoutExpired:
+        return {
+            "status": "timeout",
+            "command": f"srun --partition={partition} {script}",
+        }
+    except KeyboardInterrupt:
+        if process and process.poll() is None:
+            log_warning(f"⚠️  Terminating SLURM job due to interrupt...")
+            process.terminate()
+            try:
+                process.wait(timeout=5)
+            except subprocess.TimeoutExpired:
+                log_warning(f"⚠️  Job didn't terminate, killing...")
+                process.kill()
+                process.wait()
+        return {
+            "status": "interrupted",
+            "error": "SLURM calculation interrupted by user",
+            "command": f"srun --partition={partition} {script}",
+        }
+    except Exception as e:
+        return {
+            "status": "error",
+            "error": str(e),
+            "command": f"srun --partition={partition} {script}",
+        }
+    finally:
+        os.chdir(original_cwd)
+
+
+def _run_remote_slurm_calculation(
+    working_dir: Path,
+    host: str,
+    port: int,
+    username: str,
+    password: Optional[str],
+    partition: str,
+    script: str,
+    model: Dict,
+    timeout: int,
+    start_time: datetime,
+    env_info: Dict,
+    input_files_list: List[str] = None,
+) -> Dict[str, Any]:
+    """
+    Run SLURM calculation on remote host via SSH
+
+    Args:
+        working_dir: Local directory containing input files
+        host: Remote SSH host
+        port: SSH port
+        username: SSH username
+        password: SSH password (optional)
+        partition: SLURM partition name
+        script: Script to execute via srun
+        model: Model definition dict
+        timeout: Timeout in seconds
+        start_time: Calculation start time
+        env_info: Local environment information
+        input_files_list: List of input file names in order
+
+    Returns:
+        Dict containing calculation results and status
+    """
+    from .core import is_interrupted
+
+    # Check for interrupt before starting
+    if is_interrupted():
+        return {
+            "status": "interrupted",
+            "error": "Execution interrupted by user",
+            "command": f"srun --partition={partition} {script}",
+        }
+
+    # Validate connection security
+    security_info = validate_ssh_connection_security(host, username, password)
+    for warning in security_info["warnings"]:
+        log_warning(f"Security Warning: {warning}")
+
+    log_info(f"Connecting to SSH for SLURM: {username}@{host}:{port}")
+
+    ssh_client = None
+    try:
+        # Create SSH client
+        ssh_client = paramiko.SSHClient()
+
+        # Set appropriate host key policy
+        config = get_config()
+        host_key_policy = get_host_key_policy(
+            password_provided=security_info["password_provided"],
+            auto_accept=config.ssh_auto_accept_hostkeys,
+        )
+        ssh_client.set_missing_host_key_policy(host_key_policy)
+
+        # Load known host keys
+        try:
+            ssh_client.load_system_host_keys()
+            ssh_client.load_host_keys(os.path.expanduser("~/.ssh/known_hosts"))
+        except Exception as e:
+            log_warning(f"Could not load host keys: {e}")
+
+        # Prepare connection arguments
+        connect_kwargs = {
+            "hostname": host,
+            "port": port,
+            "username": username,
+            "timeout": min(timeout, 30),
+        }
+
+        if password:
+            connect_kwargs["password"] = password
+            connect_kwargs["look_for_keys"] = False
+            connect_kwargs["allow_agent"] = False
+        else:
+            connect_kwargs["look_for_keys"] = True
+            connect_kwargs["allow_agent"] = True
+
+        ssh_client.connect(**connect_kwargs)
+
+        # Set keepalive
+        transport = ssh_client.get_transport()
+        if transport:
+            transport.set_keepalive(config.ssh_keepalive)
+
+        # Create SFTP client
+        sftp = ssh_client.open_sftp()
+
+        # Create remote temporary directory
+        try:
+            stdin, stdout, stderr = ssh_client.exec_command("pwd", timeout=10)
+            remote_root_dir = stdout.read().decode("utf-8").strip()
+        except Exception as e:
+            log_warning(f"Could not determine remote root directory, defaulting to ~/: {e}")
+            remote_root_dir = "~"
+
+        # Create unique remote directory
+        local_dir_identifier = working_dir.name
+        unique_id = uuid.uuid4().hex[:8]
+        remote_temp_dir = f"{remote_root_dir}/.fz/tmp/fz_slurm_{local_dir_identifier}_{unique_id}"
+
+        ssh_client.exec_command(f"mkdir -p {remote_temp_dir}")
+        log_info(f"Created remote directory: {remote_temp_dir}")
+        log_info(f"🖥️  SLURM calculation on remote: {username}@{host}:{remote_temp_dir}")
+
+        try:
+            # Transfer input files to remote
+            _transfer_files_to_remote(sftp, working_dir, remote_temp_dir)
+
+            # Execute SLURM command on remote
+            result = _execute_remote_slurm_command(
+                ssh_client,
+                partition,
+                script,
+                remote_temp_dir,
+                working_dir,
+                timeout,
+                start_time,
+                env_info,
+                input_files_list,
+            )
+
+            # Transfer results back
+            _transfer_results_from_remote(sftp, remote_temp_dir, working_dir)
+
+            # Parse output using fzo
+            from .core import fzo
+
+            if result["status"] == "done":
+                try:
+                    output_results = fzo(working_dir, model)
+                    if hasattr(output_results, "to_dict"):
+                        output_dict = output_results.iloc[0].to_dict()
+                    else:
+                        output_dict = output_results
+                    result.update(output_dict)
+                    result["calculator"] = f"slurm://{host}:{partition}"
+                    result["command"] = f"srun --partition={partition} {script}"
+                except Exception as e:
+                    log_warning(f"Could not parse output: {e}")
+                    result["error"] = str(e)
+
+            if "command" not in result:
+                result["command"] = f"srun --partition={partition} {script}"
+
+            return result
+
+        finally:
+            # Cleanup remote directory
+            try:
+                ssh_client.exec_command(f"rm -rf {remote_temp_dir}")
+                log_info(f"Cleaned up remote directory: {remote_temp_dir}")
+            except Exception as e:
+                log_warning(f"Could not cleanup remote directory: {e}")
+
+            sftp.close()
+
+    except Exception as e:
+        return {"status": "error", "error": f"Remote SLURM calculation failed: {str(e)}"}
+    finally:
+        if ssh_client:
+            try:
+                ssh_client.close()
+            except:
+                pass
+
+
+def _execute_remote_slurm_command(
+    ssh_client,
+    partition: str,
+    script: str,
+    remote_dir: str,
+    local_dir: Path,
+    timeout: int,
+    start_time: datetime,
+    env_info: Dict,
+    input_files_list: List[str] = None,
+) -> Dict[str, Any]:
+    """
+    Execute SLURM command on remote server with interrupt handling
+
+    Args:
+        ssh_client: SSH client connection
+        partition: SLURM partition name
+        script: Script to execute
+        remote_dir: Remote directory path
+        local_dir: Local directory path
+        timeout: Timeout in seconds
+        start_time: Start time of execution
+        env_info: Environment information
+        input_files_list: List of input file names in order
+
+    Returns:
+        Dict with execution results
+    """
+    from .core import is_interrupted
+
+    # Check for interrupt before starting
+    if is_interrupted():
+        return {
+            "status": "interrupted",
+            "error": "Execution interrupted by user",
+            "command": f"srun --partition={partition} {script}",
+        }
+
+    # Build arguments from input files list
+    input_argument = " ".join(input_files_list) if input_files_list else "."
+
+    # Construct full SLURM command
+    full_command = f"cd {remote_dir} && srun --partition={partition} {script} {input_argument}"
+
+    log_info(f"Executing remote SLURM command: {full_command}")
+
+    # Execute command
+    command_start_time = datetime.now()
+    stdin, stdout, stderr = ssh_client.exec_command(full_command, timeout=timeout)
+
+    # Get the channel for polling
+    channel = stdout.channel
+
+    # Poll for completion with interrupt checking
+    poll_interval = 0.5
+    elapsed_time = 0.0
+
+    try:
+        while not channel.exit_status_ready():
+            # Check if user requested interrupt
+            if is_interrupted():
+                log_warning(f"⚠️  Interrupt detected, terminating remote SLURM job...")
+                try:
+                    channel.send('\x03')  # Send Ctrl+C
+                    time.sleep(0.5)
+
+                    if not channel.exit_status_ready():
+                        # Try to cancel the SLURM job
+                        # Note: This is a best-effort attempt. In production, you might want to
+                        # track the SLURM job ID and use scancel
+                        kill_cmd = f"pkill -P $(pgrep -f 'srun.*{partition}')"
+                        try:
+                            ssh_client.exec_command(kill_cmd, timeout=2)
+                        except:
+                            pass
+                except Exception as e:
+                    log_warning(f"⚠️  Could not terminate remote SLURM job: {e}")
+
+                raise KeyboardInterrupt("Remote SLURM job interrupted by user")
+
+            # Check for timeout
+            if elapsed_time >= timeout:
+                log_warning(f"⚠️  Remote SLURM job timeout after {timeout}s")
+                try:
+                    channel.send('\x03')
+                    time.sleep(0.5)
+                except:
+                    pass
+                return {
+                    "status": "timeout",
+                    "error": f"SLURM job timed out after {timeout} seconds",
+                    "command": full_command,
+                }
+
+            time.sleep(poll_interval)
+            elapsed_time += poll_interval
+
+        # Get exit status
+        exit_code = channel.recv_exit_status()
+        command_end_time = datetime.now()
+
+    except KeyboardInterrupt:
+        try:
+            channel.close()
+        except:
+            pass
+        return {
+            "status": "interrupted",
+            "error": "Remote SLURM calculation interrupted by user",
+            "command": full_command,
+        }
+
+    # Get output
+    stdout_data = stdout.read().decode("utf-8")
+    stderr_data = stderr.read().decode("utf-8")
+
+    # Calculate timing
+    total_execution_time = (command_end_time - start_time).total_seconds()
+    command_execution_time = (command_end_time - command_start_time).total_seconds()
+
+    # Get remote system information
+    remote_info_cmd = "hostname; whoami; pwd; uname -s; uname -a"
+    try:
+        _, remote_stdout, _ = ssh_client.exec_command(remote_info_cmd, timeout=10)
+        remote_info_lines = remote_stdout.read().decode("utf-8").strip().split("\n")
+        remote_hostname = remote_info_lines[0] if len(remote_info_lines) > 0 else "unknown"
+        remote_user = remote_info_lines[1] if len(remote_info_lines) > 1 else "unknown"
+        remote_pwd = remote_info_lines[2] if len(remote_info_lines) > 2 else "unknown"
+        remote_os = remote_info_lines[3] if len(remote_info_lines) > 3 else "unknown"
+        remote_platform = remote_info_lines[4] if len(remote_info_lines) > 4 else "unknown"
+    except:
+        remote_hostname = remote_user = remote_pwd = remote_os = remote_platform = "unknown"
+
+    # Create enhanced log files remotely
+    log_command = f"""cd {remote_dir}
+
+# Create enhanced log.txt
+cat > log.txt << 'EOF'
+Command: {full_command}
+Exit code: {exit_code}
+SLURM partition: {partition}
+Time start: {start_time.isoformat()}
+Time end: {command_end_time.isoformat()}
+Command execution time: {command_execution_time:.3f} seconds
+Total execution time: {total_execution_time:.3f} seconds
+Local user: {env_info.get('user', 'unknown')}
+Local hostname: {env_info.get('hostname', 'unknown')}
+Local operating system: {env_info.get('operating_system', 'unknown')}
+Local working directory: {env_info.get('working_dir', 'unknown')}
+Remote user: {remote_user}
+Remote hostname: {remote_hostname}
+Remote operating system: {remote_os}
+Remote platform: {remote_platform}
+Remote working directory: {remote_pwd}
+Timestamp: $(date)
+EOF
+
+# Create output files
+cat > out.txt << 'EOF'
+{stdout_data}
+EOF
+
+cat > err.txt << 'EOF'
+{stderr_data}
+EOF
+"""
+    ssh_client.exec_command(log_command, timeout=30)
+
+    if exit_code != 0:
+        return {"status": "failed", "exit_code": exit_code, "stderr": stderr_data}
+
+    return {"status": "done", "stdout": stdout_data, "stderr": stderr_data}
+
+
 def _transfer_files_to_remote(sftp, local_dir: Path, remote_dir: str) -> None:
     """
     Transfer files from local directory to remote directory via SFTP
diff --git a/tests/test_slurm_runner.py b/tests/test_slurm_runner.py
new file mode 100644
index 0000000..a245aec
--- /dev/null
+++ b/tests/test_slurm_runner.py
@@ -0,0 +1,200 @@
+"""
+Test SLURM runner functionality
+"""
+import pytest
+import tempfile
+from pathlib import Path
+from fz.runners import parse_slurm_uri, _validate_calculator_uri
+
+
+class TestSlurmUriParsing:
+    """Test SLURM URI parsing functionality"""
+
+    def test_parse_slurm_uri_local_simple(self):
+        """Test parsing simple local SLURM URI"""
+        host, port, username, password, partition, script = parse_slurm_uri(
+            "slurm://compute/run.sh"
+        )
+        assert host is None
+        assert port is None
+        assert username is None
+        assert password is None
+        assert partition == "compute"
+        assert script == "run.sh"
+
+    def test_parse_slurm_uri_remote_with_host(self):
+        """Test parsing remote SLURM URI with host"""
+        host, port, username, password, partition, script = parse_slurm_uri(
+            "slurm://cluster.edu:gpu/run.sh"
+        )
+        assert host == "cluster.edu"
+        assert port == 22
+        assert username is None
+        assert password is None
+        assert partition == "gpu"
+        assert script == "run.sh"
+
+    def test_parse_slurm_uri_remote_with_user(self):
+        """Test parsing remote SLURM URI with user"""
+        host, port, username, password, partition, script = parse_slurm_uri(
+            "slurm://user@cluster.edu:gpu/run.sh"
+        )
+        assert host == "cluster.edu"
+        assert port == 22
+        assert username == "user"
+        assert password is None
+        assert partition == "gpu"
+        assert script == "run.sh"
+
+    def test_parse_slurm_uri_remote_with_user_and_port(self):
+        """Test parsing remote SLURM URI with user and custom port"""
+        host, port, username, password, partition, script = parse_slurm_uri(
+            "slurm://user@cluster.edu:2222:gpu/run.sh"
+        )
+        assert host == "cluster.edu"
+        assert port == 2222
+        assert username == "user"
+        assert password is None
+        assert partition == "gpu"
+        assert script == "run.sh"
+
+    def test_parse_slurm_uri_remote_with_password(self):
+        """Test parsing remote SLURM URI with password"""
+        host, port, username, password, partition, script = parse_slurm_uri(
+            "slurm://user:pass123@cluster.edu:gpu/run.sh"
+        )
+        assert host == "cluster.edu"
+        assert port == 22
+        assert username == "user"
+        assert password == "pass123"
+        assert partition == "gpu"
+        assert script == "run.sh"
+
+    def test_parse_slurm_uri_remote_host_port_partition(self):
+        """Test parsing remote SLURM URI with host:port:partition"""
+        host, port, username, password, partition, script = parse_slurm_uri(
+            "slurm://cluster.edu:2222:gpu/run.sh"
+        )
+        assert host == "cluster.edu"
+        assert port == 2222
+        assert username is None
+        assert password is None
+        assert partition == "gpu"
+        assert script == "run.sh"
+
+    def test_parse_slurm_uri_script_with_path(self):
+        """Test parsing SLURM URI with script path"""
+        host, port, username, password, partition, script = parse_slurm_uri(
+            "slurm://compute/path/to/script.sh"
+        )
+        assert host is None
+        assert partition == "compute"
+        assert script == "path/to/script.sh"
+
+    def test_parse_slurm_uri_missing_script(self):
+        """Test parsing SLURM URI without script raises error"""
+        with pytest.raises(ValueError, match="script path is required"):
+            parse_slurm_uri("slurm://compute/")
+
+    def test_parse_slurm_uri_missing_slash(self):
+        """Test parsing SLURM URI without slash raises error"""
+        with pytest.raises(ValueError, match="Expected format"):
+            parse_slurm_uri("slurm://compute")
+
+    def test_parse_slurm_uri_missing_partition(self):
+        """Test parsing SLURM URI with empty partition raises error"""
+        # This case: slurm:///script.sh (empty partition)
+        with pytest.raises(ValueError, match="partition is required"):
+            parse_slurm_uri("slurm:///script.sh")
+
+    def test_parse_slurm_uri_user_without_host(self):
+        """Test parsing SLURM URI with user but no host raises error"""
+        with pytest.raises(ValueError, match="host must also be provided"):
+            parse_slurm_uri("slurm://user@gpu/script.sh")
+
+
+class TestSlurmUriValidation:
+    """Test SLURM URI validation functionality"""
+
+    def test_validate_slurm_uri_valid(self):
+        """Test validation of valid SLURM URI"""
+        # Should not raise
+        _validate_calculator_uri("slurm://compute/run.sh")
+
+    def test_validate_slurm_uri_invalid_format(self):
+        """Test validation of invalid SLURM URI format"""
+        with pytest.raises(ValueError, match="Invalid SLURM calculator URI"):
+            _validate_calculator_uri("slurm://compute")
+
+    def test_validate_calculator_uri_slurm_scheme(self):
+        """Test that slurm:// is a supported scheme"""
+        # Should not raise
+        _validate_calculator_uri("slurm://partition/script.sh")
+
+    def test_validate_slurm_uri_missing_partition(self):
+        """Test validation catches missing partition"""
+        with pytest.raises(ValueError, match="Invalid SLURM calculator URI"):
+            _validate_calculator_uri("slurm:///script.sh")
+
+
+class TestSlurmCalculatorIntegration:
+    """Integration tests for SLURM calculator"""
+
+    def test_slurm_local_simple_calculation(self):
+        """Test simple local SLURM calculation (requires srun)"""
+        pytest.skip("Requires SLURM installation - skipping in CI")
+        # This test would require an actual SLURM installation
+        # Example implementation:
+        # from fz import fzr
+        # with tempfile.TemporaryDirectory() as tmpdir:
+        #     input_file = Path(tmpdir) / "input.txt"
+        #     input_file.write_text("x = ${x}\n")
+        #     model = {"output": {"result": "cat output.txt"}}
+        #     results = fzr(
+        #         input_file,
+        #         model=model,
+        #         variables={"x": [1, 2]},
+        #         calculator="slurm://debug/echo"
+        #     )
+        #     assert len(results) == 2
+
+    def test_slurm_remote_calculation(self):
+        """Test remote SLURM calculation via SSH (requires SLURM cluster)"""
+        pytest.skip("Requires remote SLURM cluster - skipping in CI")
+        # This test would require access to a remote SLURM cluster
+        # Example implementation:
+        # from fz import fzr
+        # with tempfile.TemporaryDirectory() as tmpdir:
+        #     input_file = Path(tmpdir) / "input.txt"
+        #     input_file.write_text("x = ${x}\n")
+        #     model = {"output": {"result": "cat output.txt"}}
+        #     results = fzr(
+        #         input_file,
+        #         model=model,
+        #         variables={"x": [1, 2]},
+        #         calculator="slurm://user@cluster.edu:compute/submit.sh"
+        #     )
+        #     assert len(results) == 2
+
+
+class TestSlurmErrorHandling:
+    """Test SLURM error handling"""
+
+    def test_invalid_partition_name(self):
+        """Test error handling for invalid partition names"""
+        # This would require SLURM to be installed
+        pytest.skip("Requires SLURM installation - skipping in CI")
+
+    def test_timeout_handling(self):
+        """Test timeout handling for SLURM jobs"""
+        # This would require SLURM to be installed
+        pytest.skip("Requires SLURM installation - skipping in CI")
+
+    def test_job_failure_handling(self):
+        """Test handling of failed SLURM jobs"""
+        # This would require SLURM to be installed
+        pytest.skip("Requires SLURM installation - skipping in CI")
+
+
+if __name__ == "__main__":
+    pytest.main([__file__, "-v"])