Bringing Back the Third Pedal: Engineering a Clutch System for Electric Vehicles

This is a bit of an odd one. A technical deep-dive into the hardware and software architecture required to integrate traditional clutch mechanisms with EV powertrains—and why motorsport might demand it.

Electric vehicles have solved the clutch. That's the problem.

The instant torque delivery and seamless power modulation of electric motors eliminated the mechanical necessity for a clutch. But in doing so, we lost something that many drivers consider essential: the ability to mechanically gate power, build rotational inertia, and use clutch slip as a dynamic vehicle control input. This becomes even more elevated in motorsports.

This post explores what it would take to engineer that experience back into an EV, not as a gimmick, but as a legitimate performance system capable of supporting advanced driving techniques like clutch-kicking, controlled wheelspin launches, and the nuanced throttle-clutch interplay that defines spirited driving.

Part 1: Understanding What We're Replicating

Why ICE Vehicles Need Clutches

In a conventional internal combustion drivetrain, the clutch serves three primary functions:

1. Torque interruption: Disconnecting the engine from the drivetrain to allow gear changes and prevent stalling at rest
2. Slip-based modulation: Allowing progressive engagement for smooth starts and fine control during low-speed manoeuvres
3. Inertial decoupling: Separating the rotating mass of the engine from the wheels, enabling techniques like clutch-kicking where stored flywheel energy is rapidly released

The third function is critically important for motorsport applications. When a driver "kicks" the clutch—momentarily disengaging and re-engaging—they're exploiting the rotational inertia stored in the flywheel and engine internals. This sudden torque spike can break rear traction on demand, initiating or extending a drift without requiring additional throttle input.

Electric motors produce peak torque from 0 RPM and can be electronically controlled with millisecond precision. There's no idle speed to maintain, no stall condition to avoid, and torque can be modulated far more precisely through software than any clutch could achieve mechanically.

Most EVs use single-speed reduction gearboxes because electric motors have a broad, usable power band. My favourite car company, Porsche, has the Taycan's two-speed rear transmission as a notable exception. But even this uses a dog-clutch mechanism for ratio changes rather than a driver-operated friction clutch.

Part 2: Hardware Architecture

Building a functional clutch system for an EV requires addressing several interconnected engineering challenges.

2.1 The Clutch Assembly

Clutch Type Selection

Single-plate dry clutch (traditional automotive)

• Familiar pedal feel and engagement characteristics
• Proven thermal capacity for street use
• Limited slip capacity under sustained abuse
• Mass: 8-12kg including flywheel

Multi-plate wet clutch (motorcycle/motorsport)

• Superior heat dissipation via oil cooling
• More compact packaging
• Progressive engagement characteristics
• Better suited for repeated clutch-kick cycles
• Mass: 4-8kg

Carbon-carbon clutch (high-performance motorsport)

• Exceptional thermal stability (operating temps to 800°C)
• Aggressive engagement—less suitable for street use
• Spendy (€3,000-15,000)
• Requires careful temperature management

Clutch Sizing

Clutch torque capacity must exceed peak motor torque with appropriate safety margins:

Required clutch capacity = Peak motor torque × Safety factor × Drivetrain ratio

Example for a 450Nm motor with 8:1 reduction:
Wheel torque = 450 × 8 = 3,600Nm
Clutch capacity (at wheel) = 3,600 × 1.25 = 4,500Nm minimum

For motorsport applications where repeated clutch drops and abuse cycles are expected, increase the safety factor to 1.5-2.0.

2.2 The Flywheel Problem

This is perhaps the most significant engineering challenge. ICE vehicles have substantial rotating mass—a typical flywheel weighs 6-10kg with a moment of inertia around 0.15-0.25 kg·m². This stored energy is what makes clutch-kicking work.

Electric motor rotors have much lower inertia—typically 0.02-0.05 kg·m² for automotive-scale motors. Without additional rotating mass, clutch disengagement doesn't "store" energy.

Solution Options

Option A: Physical flywheel

Add a dedicated flywheel between the motor and clutch:

• Mass: 5-10kg
• Moment of inertia: 0.1-0.2 kg·m²
• Penalty: Added weight, packaging challenges, increased drivetrain losses

Option B: Software-simulated inertia

Use motor control algorithms to simulate flywheel behaviour:

• When clutch disengages, motor accelerates to simulate "free-revving"
• Motor controller maintains virtual RPM based on inertia model
• Re-engagement torque calculated from virtual stored energy

Option C: Hybrid approach

Modest physical flywheel (3-5kg, ~0.08 kg·m²) combined with software augmentation:

• Physical mass provides genuine mechanical feel
• Software extends effective inertia range
• Motor can add energy during "rev" phase to simulate larger flywheel
• Best balance of authenticity and practicality

Realistically, this is the best approach to it. Some feeling in the physical motion but software engagement to engage the motor performance.

2.3 Gearbox Integration

Do We Need Actual Gear Ratios?

For pure driver engagement without performance benefit, a single-ratio gearbox with clutch would suffice—the clutch provides the connection feel, the motor provides the torque, no ratio changes needed. Also, less mucking about, less stuff to break or maintain.

However, for authentic motorsport application, multiple ratios offer genuine advantages:

1. Motor efficiency optimisation: Keeping the motor in its peak efficiency band
2. Regenerative braking enhancement: Lower gears provide more aggressive engine braking feel
3. Top speed vs acceleration trade-offs: Gear selection as a strategic choice
4. Authentic heel-toe and rev-matching requirements: Creating the "problem" that skilled driving techniques solve

That said, heel-toe and rev-matching can be 'faked' in software.

Gearbox Specifications

A 3-4 speed sequential or H-pattern gearbox would provide meaningful ratio spread without unnecessary complexity:

Final drive ratio of 3.5-4.0:1 with a typical EV motor (6,000-12,000 RPM redline) would provide appropriate wheel speeds.

Synchromesh vs dogbox: For motorsport, dog-engagement boxes offer faster shifts and can handle clutchless upshifts. For road use, synchromesh provides forgiveness for imperfect rev-matching.

2.4 Mechanical Layout

[Battery] → [Inverter] → [Motor] → [Flywheel] → [Clutch] → [Gearbox] → [Differential] → [Wheels]
                              ↑
                    [Motor Position Sensor]
                              ↑
                    [Clutch Position Sensor]
                              ↑
                    [Gearbox Input/Output Speed Sensors]

Clutch Actuation

Hydraulic:

• Traditional master/slave cylinder arrangement
• Familiar pedal feel
• Progressive engagement
• Clutch position sensor (linear potentiometer or Hall effect) on slave cylinder

Cable:

• Lighter weight
• Direct mechanical feedback
• More difficult to package with EV motor positioning

Electro-hydraulic:

• Enables software assistance (auto-blip, anti-stall)
• Can simulate different pedal weights/engagement points
• Higher complexity and cost

2.5 Sensor Requirements

Minimum sensor suite for system operation:

Part 3: Software Architecture

The software stack transforms sensor inputs into appropriate motor behaviour, creating the illusion—and in many ways the reality—of a traditional drivetrain.

3.1 Core Control Loop

The primary control loop runs at 1-10kHz, processing sensor data and commanding motor torque:

┌─────────────────────────────────────────────────────────────────┐
│                      MAIN CONTROL LOOP (1kHz)                    │
├─────────────────────────────────────────────────────────────────┤
│                                                                  │
│  1. Read Sensors                                                 │
│     ├── Motor RPM                                               │
│     ├── Clutch position (0-100%)                                │
│     ├── Gearbox input/output speeds                             │
│     ├── Throttle position                                       │
│     └── Gear selector state                                     │
│                                                                  │
│  2. Calculate Clutch State                                       │
│     ├── Fully disengaged: position < 5%                         │
│     ├── Slip zone: 5% < position < 95%                          │
│     └── Fully engaged: position > 95%                           │
│                                                                  │
│  3. Determine Operating Mode                                     │
│     ├── DISENGAGED: Motor follows virtual inertia model         │
│     ├── SLIPPING: Torque limited by clutch friction model       │
│     └── ENGAGED: Direct torque pass-through                     │
│                                                                  │
│  4. Calculate Target Motor Torque                                │
│     └── Based on mode, throttle, clutch position, RPM           │
│                                                                  │
│  5. Apply Safety Limits                                          │
│     ├── Thermal protection                                      │
│     ├── Overspeed protection                                    │
│     └── Current limits                                          │
│                                                                  │
│  6. Command Inverter                                             │
│                                                                  │
└─────────────────────────────────────────────────────────────────┘

3.2 Clutch Engagement Model

The relationship between clutch pedal position and transmitted torque follows a non-linear curve that mimics traditional clutch behaviour:

Transmitted Torque = f(clutch_position, slip_speed, temperature)

Where:
- Friction coefficient μ varies with slip speed (Stribeck curve)
- Clamp force increases non-linearly with pedal travel
- Temperature affects friction coefficient

Simplified clutch torque calculation:

This is not fully accurate, nor has it been deployed anywhere.

def calculate_clutch_torque(clutch_position, motor_rpm, gearbox_input_rpm, 
                            clutch_temp, max_clutch_torque):
    
    # Clutch engagement curve (non-linear)
    # Bite point around 20-30% travel, full engagement by 90%
    if clutch_position < 0.15:
        engagement = 0.0
    elif clutch_position < 0.35:
        # Progressive engagement zone
        engagement = (clutch_position - 0.15) / 0.20 * 0.3
    elif clutch_position < 0.90:
        # Linear engagement zone  
        engagement = 0.3 + (clutch_position - 0.35) / 0.55 * 0.7
    else:
        engagement = 1.0
    
    # Slip speed affects friction (Stribeck effect)
    slip_rpm = abs(motor_rpm - gearbox_input_rpm)
    if slip_rpm < 50:
        friction_modifier = 1.0  # Static friction
    elif slip_rpm < 500:
        friction_modifier = 0.85 + 0.15 * (500 - slip_rpm) / 450
    else:
        friction_modifier = 0.85  # Dynamic friction
    
    # Temperature derating
    if clutch_temp > 250:
        temp_modifier = max(0.5, 1.0 - (clutch_temp - 250) / 200)
    else:
        temp_modifier = 1.0
    
    return max_clutch_torque * engagement * friction_modifier * temp_modifier

3.3 Virtual Inertia Simulation

When the clutch is disengaged, the motor must behave as if connected to a flywheel. This requires simulating the physics of rotating mass:

class VirtualFlywheel:
    def __init__(self, physical_inertia, virtual_inertia, friction_torque):
        self.J_physical = physical_inertia  # kg·m² (actual motor + flywheel)
        self.J_virtual = virtual_inertia    # kg·m² (simulated additional)
        self.J_total = physical_inertia + virtual_inertia
        self.T_friction = friction_torque   # Nm (simulated engine friction)
        self.omega = 0  # rad/s
        
    def update(self, throttle_position, dt):
        # Calculate "throttle torque" - what the virtual engine would produce
        # This maps throttle to a torque curve like an ICE
        peak_torque = 450  # Nm at peak
        
        # Simple torque curve that builds with RPM (unlike real EV instant torque)
        rpm = self.omega * 60 / (2 * 3.14159)
        rpm_factor = min(1.0, rpm / 3000) if rpm > 500 else rpm / 500 * 0.3
        
        throttle_torque = throttle_position * peak_torque * rpm_factor
        
        # Net torque considering friction losses
        net_torque = throttle_torque - self.T_friction - 0.001 * self.omega
        
        # Angular acceleration: α = T/J
        alpha = net_torque / self.J_total
        
        # Update angular velocity
        self.omega += alpha * dt
        self.omega = max(0, min(self.omega, 1200))  # Clamp to idle-redline
        
        return self.omega, net_torque

This creates the satisfying "blip" when the driver opens the throttle with the clutch in—the motor accelerates as if unburdened, but at a rate consistent with having real rotating mass.

3.4 Clutch-Kick Detection and Response

For motorsport applications, detecting and responding to clutch-kick inputs is essential:

class ClutchKickDetector:
    def __init__(self):
        self.clutch_history = []
        self.kick_detected = False
        self.kick_magnitude = 0
        
    def update(self, clutch_position, dt):
        self.clutch_history.append((clutch_position, dt))
        
        # Keep 200ms of history
        while sum(h[1] for h in self.clutch_history) > 0.2:
            self.clutch_history.pop(0)
        
        # Detect kick pattern: rapid disengage followed by rapid re-engage
        if len(self.clutch_history) > 10:
            positions = [h[0] for h in self.clutch_history]
            
            # Find local minimum (clutch dip)
            min_pos = min(positions)
            min_idx = positions.index(min_pos)
            
            # Check for rapid dip and return
            if min_idx > 2 and min_idx < len(positions) - 2:
                pre_dip = positions[0]
                post_dip = positions[-1]
                
                # Kick criteria: started engaged, dipped below 30%, returned to >80%
                if pre_dip > 0.7 and min_pos < 0.3 and post_dip > 0.8:
                    time_span = sum(h[1] for h in self.clutch_history)
                    
                    # Must happen within 150ms
                    if time_span < 0.15:
                        self.kick_detected = True
                        self.kick_magnitude = (pre_dip - min_pos) * (1 / time_span)
                        return True
        
        self.kick_detected = False
        return False

When a kick is detected, the motor controller should:

1. Store current motor angular momentum based on virtual inertia model
2. On re-engagement, deliver a torque spike proportional to the "stored" energy
3. Overshoot wheel torque briefly to simulate the shock load of clutch dump

def handle_clutch_kick(self, stored_momentum, engagement_speed):
    # Calculate energy to release
    stored_energy = 0.5 * self.J_total * (stored_momentum ** 2)
    
    # Spike duration inversely proportional to engagement speed
    spike_duration = 0.05 / engagement_speed  # 50-150ms typical
    
    # Peak torque spike
    spike_torque = stored_energy / spike_duration
    
    # Limit to reasonable values
    spike_torque = min(spike_torque, self.max_motor_torque * 1.5)
    
    return spike_torque, spike_duration

3.5 Rev-Matching and Engine Braking Simulation

For downshifts, the system needs to simulate engine braking and enable heel-toe technique:

Automatic rev-matching:

Note that this could be an optional mode, as I reckon purists would rather not have this.

def auto_rev_match(self, current_gear, target_gear, vehicle_speed):
    # Calculate target RPM for new gear
    target_rpm = vehicle_speed * gear_ratios[target_gear] * final_drive * (60 / wheel_circumference)
    current_rpm = self.motor_rpm
    
    rpm_delta = target_rpm - current_rpm
    
    if rpm_delta > 100:  # Downshift, need blip
        # Ramp motor to target RPM while clutch is disengaged
        self.target_rpm = target_rpm
        self.blip_active = True

Engine braking simulation:

When the throttle is closed with the clutch engaged, apply regenerative braking torque that mimics ICE engine braking:

def calculate_engine_braking(self, motor_rpm, gear_ratio, throttle_position):
    if throttle_position > 0.05:
        return 0  # No engine braking with throttle applied
    
    # Engine braking proportional to RPM (mimics pumping losses)
    base_braking = 50  # Nm at idle
    rpm_factor = motor_rpm / 6000  # Normalized to redline
    
    # Higher gears = more engine braking (higher load on motor)
    gear_factor = gear_ratio / gear_ratios[1]  # Normalized to first gear
    
    braking_torque = base_braking * (1 + rpm_factor) * gear_factor
    
    # Apply as regenerative braking
    return -braking_torque

3.6 Anti-Stall and Safety Systems

Unlike ICE vehicles, an EV can't stall. That said, it could simulate the consequence of poor clutch work:

def check_stall_condition(self, motor_rpm, clutch_position, throttle_position):
    # "Stall" if clutch engaged with low RPM and low throttle
    if clutch_position > 0.8 and motor_rpm < 300 and throttle_position < 0.1:
        self.stall_timer += dt
        
        if self.stall_timer > 0.5:  # 500ms grace period
            self.trigger_stall()
            return True
    else:
        self.stall_timer = 0
    
    return False

def trigger_stall(self):
    # Cut motor torque completely
    self.motor_torque_command = 0
    self.stall_active = True
    
    # Require clutch disengage and "restart" sequence
    # (clutch in, press start button or brake pedal)

Part 4: Motorsport-Specific Considerations

4.1 Drift Initiation Techniques

Clutch kick: Already covered above.

Power-over: Requires the motor to deliver torque quickly enough to break traction. EVs excel here, but with a clutch, the driver can pre-load torque against a slipping clutch, then dump it suddenly.

Clutch dump from standstill: Motor winds up against clutch slip, clutch release delivers full torque instantly. The system needs to handle the thermal load of sustained slip during wind-up.

4.2 Launch Control Integration

With a clutch, launch control becomes a driver-active system rather than fully automated:

class LaunchControlWithClutch:
    def __init__(self):
        self.armed = False
        self.launch_rpm = 4500
        self.slip_target = 0.15  # 15% wheelspin
        
    def update(self, throttle, clutch_position, vehicle_speed):
        # Arm when stationary, clutch in, throttle applied
        if vehicle_speed < 2 and clutch_position < 0.2 and throttle > 0.9:
            self.armed = True
            # Hold motor at launch RPM
            return self.launch_rpm, "RPM_HOLD"
        
        # Launch when clutch released
        if self.armed and clutch_position > 0.7:
            self.armed = False
            # Switch to traction control with slip target
            return self.slip_target, "TRACTION_CONTROL"
        
        return None, "NORMAL"

4.3 Thermal Management

Sustained clutch abuse generates significant heat. The system needs:

1. Clutch temperature monitoring with warnings at 250°C and cutback at 300°C
2. Active cooling if using wet clutch (oil cooler circuit)
3. Passive cooling period after sustained abuse
4. Driver feedback (temperature gauge, warning lights/sounds)

def thermal_protection(self, clutch_temp, slip_speed, slip_duration):
    heat_input = self.clutch_torque * slip_speed * slip_duration
    
    # Warning threshold
    if clutch_temp > 250:
        self.clutch_warning = True
        
    # Progressive torque limiting above 280°C
    if clutch_temp > 280:
        limit_factor = max(0.3, 1.0 - (clutch_temp - 280) / 100)
        self.max_clutch_torque *= limit_factor
        
    # Critical protection - force disengage above 350°C
    if clutch_temp > 350:
        self.force_clutch_open = True

4.4 Left-Foot Braking Considerations

Rally and circuit drivers use left-foot braking extensively. With a clutch, the left foot can modulate both clutch and brake. The system should:

1. Detect left-foot braking style (brake without clutch movement)
2. Maintain motor torque appropriately during braking
3. Not trigger anti-stall when braking at low speed with clutch engaged

Part 5: Implementation Challenges and Solutions

5.1 Noise, Vibration, Harshness

Adding a clutch introduces engagement shock and potential driveline shunt. Mitigation strategies:

• Dual-mass flywheel: Absorbs torsional spikes but adds complexity
• Software torque shaping: Briefly reduce motor torque during engagement to cushion the shock
• Progressive clutch engagement curve: Tune the friction material for gradual bite

5.2 Packaging

EV motors are typically compact and mounted low. Adding a flywheel, clutch, and gearbox significantly increases drivetrain length. Options:

• Transaxle: Clutch and gearbox alongside motor (FWD/AWD applications)
• Longitudinal: Traditional front-engine-rear-drive arrangement (best for motorsport)
• In-board mount: Motor amidships with driveshafts to wheels (also has weight distribution benefits)

5.3 Weight Penalty

Estimated system weight addition over single-speed EV drivetrain:

This is significant. For motorsport, the driver engagement and technique options may outweigh the penalty. For normal driving... the sheer fun is the point.

5.4 Efficiency Loss

Adding mechanical components reduces efficiency:

• Flywheel bearing losses: 0.5-1%
• Clutch drag (when engaged): 0.2-0.5%
• Gearbox losses: 2-4%
• Total: 3-5.5% drivetrain loss

Compared to the 90-95% efficiency of a typical EV single-speed drivetrain, this brings overall efficiency closer to 85-90%—still better than most ICE vehicles.

Conclusion

Building a proper clutch system for an EV is not trivial. It also might be pointless, but I love the idea of it (hence the volume of research here). It requires careful mechanical engineering to handle the torque and thermal loads, sophisticated software to simulate the physics of rotating mass and friction engagement, and thoughtful integration to preserve the benefits of electric propulsion while reintroducing the tactile control that many drivers crave. But I think all of this, packaged properly, opens up an enormous opportunity.

In my mind the opportunity is clear for sports applications; particularly drifting or touring car type series. The other one is restomodding old cars that are worn, battered and bruised.

The result wouldn't be a compromise. It would be the best of both worlds: instant low-end torque, precise electronic control, zero emissions, and the ability to kick the clutch into a corner or heel-toe a downshift.

The driver is not obsolete. The connection between human intention and vehicle response doesn't have to be severed just because the fuel source changed. Sometimes progress means finding new ways to preserve what matters.