diff --git a/ext/JuMPModels/bioreactor.jl b/ext/JuMPModels/bioreactor.jl
index aa2d27e7..4950a024 100644
--- a/ext/JuMPModels/bioreactor.jl
+++ b/ext/JuMPModels/bioreactor.jl
@@ -79,10 +79,10 @@ function OptimalControlProblems.bioreactor(
     @variables(
         model,
         begin
-            y[0:N] ≥ y_l, (start = 50)
-            s[0:N] ≥ s_l, (start = 50)
-            b[0:N] ≥ b_l, (start = 50)
-            u_l ≤ u[0:N] ≤ u_u, (start = 0.5)
+            y[0:N] ≥ 0, (start = 0.15)     
+            s[0:N] ≥ 0, (start = 2.75)     
+            b[0:N] ≥ 0.001, (start = 1.75) 
+            0 ≤ u[0:N] ≤ 1, (start = 0.5)
         end
     )
 
@@ -90,9 +90,9 @@ function OptimalControlProblems.bioreactor(
     @constraints(
         model,
         begin
-            y_t0_l ≤ y[0] ≤ y_t0_u
-            s_t0_l ≤ s[0] ≤ s_t0_u
-            b_t0_l ≤ b[0] ≤ b_t0_u
+            y[0] == 0.05  
+            s[0] == 0.5   
+            b[0] == 0.5   
         end
     )
 
diff --git a/ext/JuMPModels/glider.jl b/ext/JuMPModels/glider.jl
index 164600a7..52331893 100644
--- a/ext/JuMPModels/glider.jl
+++ b/ext/JuMPModels/glider.jl
@@ -76,12 +76,12 @@ function OptimalControlProblems.glider(
     @variables(
         model,
         begin
-            tf ≥ tf_l, (start = 1)
-            x[k = 0:N] ≥ x_l, (start = x_t0 + vx_t0 * k / N)
+            tf ≥ tf_l, (start = 100.0)  ####
+            x[k = 0:N] ≥ x_l, (start = x_t0 + (k / N) * 1248.0) ####
             y[k = 0:N], (start = y_t0 + (k / N) * (y_tf - y_t0))
             vx[k = 0:N] ≥ vx_l, (start = vx_t0)
             vy[k = 0:N], (start = vy_t0)
-            cL_min ≤ cL[k = 0:N] ≤ cL_max, (start = cL_max / 2)
+            cL_min ≤ cL[k = 0:N] ≤ cL_max, (start = 1.0) ####
         end
     )
 
diff --git a/ext/JuMPModels/robot.jl b/ext/JuMPModels/robot.jl
index 79bfadc0..bc109fba 100644
--- a/ext/JuMPModels/robot.jl
+++ b/ext/JuMPModels/robot.jl
@@ -92,22 +92,53 @@ function OptimalControlProblems.robot(
     @variables(
         model,
         begin
-            ρ_l ≤ ρ[k = 0:N] ≤ ρ_u, (start = ρ_t0)
-            θ_l ≤ θ[k = 0:N] ≤ θ_u, (start = 2π/3 * (k / N)^2)
-            ϕ_l ≤ ϕ[k = 0:N] ≤ ϕ_u, (start = ϕ_t0)
+            ρ_l ≤ ρ[k = 0:N] ≤ ρ_u
+            θ_l ≤ θ[k = 0:N] ≤ θ_u
+            ϕ_l ≤ ϕ[k = 0:N] ≤ ϕ_u
 
-            dρ[k = 0:N], (start = 0)
-            dθ[k = 0:N], (start = 4π/3 * (k / N))
-            dϕ[k = 0:N], (start = 0)
+            dρ[k = 0:N]
+            dθ[k = 0:N]
+            dϕ[k = 0:N]
 
-            uρ_l ≤ uρ[0:N] ≤ uρ_u, (start = 0)
-            uθ_l ≤ uθ[0:N] ≤ uθ_u, (start = 0)
-            uϕ_l ≤ uϕ[0:N] ≤ uϕ_u, (start = 0)
+            uρ_l ≤ uρ[0:N] ≤ uρ_u
+            uθ_l ≤ uθ[0:N] ≤ uθ_u
+            uϕ_l ≤ uϕ[0:N] ≤ uϕ_u
 
-            tf ≥ tf_l, (start = 1)
+            tf ≥ tf_l
         end
     )
 
+    #INITIAL GUESS
+    set_start_value(tf, 9.1)
+    for k in 0:grid_size
+        # Coefficient d'interpolation entre 0 et 1
+        alpha = k / grid_size
+
+        # Interpolation linéaire entre t0 et tf
+        ρ_val = ρ_t0 + alpha * (ρ_tf - ρ_t0)
+        θ_val = θ_t0 + alpha * (θ_tf - θ_t0)
+        ϕ_val = ϕ_t0 + alpha * (ϕ_tf - ϕ_t0)
+
+        # SECURITÉ ANTI-CRASH (Division par zéro)
+        if abs(ϕ_val) < 1e-6
+            ϕ_val = 1e-6
+        end
+
+        # Application des valeurs aux variables JuMP
+        set_start_value(ρ[k], ρ_val)
+        set_start_value(θ[k], θ_val)
+        set_start_value(ϕ[k], ϕ_val)
+
+        # Vitesses et contrôles à 0 par défaut
+        set_start_value(dρ[k], 0.0)
+        set_start_value(dθ[k], 0.0)
+        set_start_value(dϕ[k], 0.0)
+        
+        set_start_value(uρ[k], 0.0)
+        set_start_value(uθ[k], 0.0)
+        set_start_value(uϕ[k], 0.0)
+    end
+
     # Boundary condition
     @constraints(
         model,
@@ -137,8 +168,7 @@ function OptimalControlProblems.robot(
             #
             Δt, (tf - t0) / N
 
-            #
-            I_θ[i = 0:N], ((L - ρ[i])^3 + ρ[i]^3) * (sin(ϕ[i]))^2
+            I_θ[i = 0:N], ((L - ρ[i])^3 + ρ[i]^3) * ((sin(ϕ[i]))^2 + 1e-9)
             I_ϕ[i = 0:N], (L - ρ[i])^3 + ρ[i]^3
 
             #
diff --git a/ext/JuMPModels/space_shuttle.jl b/ext/JuMPModels/space_shuttle.jl
index 0479eebf..42d50df7 100644
--- a/ext/JuMPModels/space_shuttle.jl
+++ b/ext/JuMPModels/space_shuttle.jl
@@ -184,7 +184,7 @@ function OptimalControlProblems.space_shuttle(
     set_start_value.(model[:ψ], vec(initial_guess[:, 6]))
     set_start_value.(model[:α], vec(initial_guess[:, 7]))
     set_start_value.(model[:β], vec(initial_guess[:, 8]))
-    set_start_value.(model[:tf], (tf_l+tf_u)/2)
+    set_start_value.(model[:tf], 2000.0) #######
 
     # Functions to restore `h` and `v` to their true scale
     @expression(model, h[j = 0:N], scaled_h[j] * scaling_h)
diff --git a/ext/JuMPModels/steering.jl b/ext/JuMPModels/steering.jl
index cd40af69..8554cc42 100644
--- a/ext/JuMPModels/steering.jl
+++ b/ext/JuMPModels/steering.jl
@@ -51,7 +51,7 @@ function OptimalControlProblems.steering(
     x₄_tf = params[:x₄_tf]
 
     #
-    tf_start = 1
+    tf_start = 0.6
     function gen_x0(k, i)
         if i == 1 || i == 4
             return 0.0
diff --git a/ext/OptimalControlModels/bioreactor.jl b/ext/OptimalControlModels/bioreactor.jl
index 3f32d976..274e8e64 100644
--- a/ext/OptimalControlModels/bioreactor.jl
+++ b/ext/OptimalControlModels/bioreactor.jl
@@ -1,31 +1,7 @@
 """
 $(TYPEDSIGNATURES)
 
-Constructs an **OptimalControl problem** representing the Bioreactor problem.  
-The function defines the state and control variables, boundary conditions, path constraints, growth and light dynamics, and an objective functional.  
-It performs direct transcription to create a discretised optimal control problem (DOCP) and the corresponding nonlinear programming (NLP) model.
-
-# Arguments
-
-- `::OptimalControlBackend`: Placeholder type specifying the OptimalControl backend or solver interface.
-- `grid_size::Int=500`: (Keyword) Number of discretisation points for the direct transcription grid.
-
-# Returns
-
-- `docp`: The direct optimal control problem object representing the discretised Bioreactor problem.
-- `nlp`: The corresponding nonlinear programming model generated from the DOCP, ready for solver input.
-
-# Example
-
-```julia-repl
-julia> using OptimalControlProblems
-
-julia> docp = OptimalControlProblems.bioreactor(OptimalControlBackend(); N=100);
-```
-
-# References
-
-- BOCOP repository: https://github.com/control-toolbox/bocop/tree/main/bocop
+Constructs the **Bioreactor optimal control problem** (Autonomous formulation).
 """
 function OptimalControlProblems.bioreactor(
     ::OptimalControlBackend,
@@ -34,84 +10,79 @@ function OptimalControlProblems.bioreactor(
     parameters::Union{Nothing,NamedTuple}=nothing,
     kwargs...,
 )
-
-    # parameters
+    # --- Parameters ---
     params = parameters_data(:bioreactor, parameters)
-    t0 = params[:t0]
-    tf = params[:tf]
-    β = params[:β]
-    c = params[:c]
-    γ = params[:γ]
+    t0, tf = params[:t0], params[:tf]
+    β, c, γ = params[:β], params[:c], params[:γ]
     halfperiod = params[:halfperiod]
-    Ks = params[:Ks]
-    μ2m = params[:μ2m]
-    μbar = params[:μbar]
-    r = params[:r]
-    y_l = params[:y_l]
-    s_l = params[:s_l]
-    b_l = params[:b_l]
-    u_l = params[:u_l]
-    u_u = params[:u_u]
-    y_t0_l = params[:y_t0_l]
-    y_t0_u = params[:y_t0_u]
-    s_t0_l = params[:s_t0_l]
-    s_t0_u = params[:s_t0_u]
-    b_t0_l = params[:b_t0_l]
-    b_t0_u = params[:b_t0_u]
-
-    # Model
+    Ks, μ2m, μbar, r = params[:Ks], params[:μ2m], params[:μbar], params[:r]
+    y_l, s_l, b_l = params[:y_l], params[:s_l], params[:b_l]
+    u_l, u_u = params[:u_l], params[:u_u]
+    y_t0_l, y_t0_u = params[:y_t0_l], params[:y_t0_u]
+    s_t0_l, s_t0_u = params[:s_t0_l], params[:s_t0_u]
+    b_t0_l, b_t0_u = params[:b_t0_l], params[:b_t0_u]
+
+    # --- Model ---
     ocp = @def begin
         t ∈ [t0, tf], time
-        x = (y, s, b) ∈ R³, state
+        
+        # Vector state required by parser (4th component k is time)
+        x ∈ R⁴, state
         u ∈ R, control
 
-        x(t) ≥ [y_l, s_l, b_l]
+        # Coordinate aliases for readability
+        y = x[1]
+        s = x[2]
+        b = x[3]
+        k = x[4]
+
+        # Path constraints
+        y(t) ≥ 0
+        s(t) ≥ 0
+        b(t) ≥ 1e-3
+        k(t) ≥ t0
+        k(t) ≤ tf
+
+        # Control bounds
         u_l ≤ u(t) ≤ u_u
-        [y_t0_l, s_t0_l, b_t0_l] ≤ x(t0) ≤ [y_t0_u, s_t0_u, b_t0_u]
 
-        μ = light(t, halfperiod) * μbar
-        μ2 = growth(s(t), μ2m, Ks)
+        # Initial bounds
+        y_t0_l ≤ y(t0) ≤ y_t0_u
+        s_t0_l ≤ s(t0) ≤ s_t0_u
+        b_t0_l ≤ b(t0) ≤ b_t0_u
+        k(t0) == t0
 
-        ẋ(t) == [
-            μ * y(t) / (1 + y(t)) - (r + u(t)) * y(t),
-            -μ2 * b(t) + u(t) * β * (γ * y(t) - s(t)),
-            (μ2 - u(t) * β) * b(t),
-        ]
+        # Dynamics (Coordinatewise & Inline calculation for light)
+        
+        # dy/dt: We inline the light calculation: sin(k(t) * π / halfperiod)^2
+        ẋ[1](t) == (μbar * sin(k(t) * π / halfperiod)^2) * y(t) / (1 + y(t)) - (r + u(t)) * y(t)
 
-        -∫(μ2 * b(t) / (β + c)) → min
-    end
+        # ds/dt
+        ẋ[2](t) == -(μ2m * s(t) / (s(t) + Ks)) * b(t) + u(t) * β * (γ * y(t) - s(t))
 
-    # METHANE PROBLEM
-    # μ2 according to growth model
-    # μ according to light model
-    # time scale is [0,10] for 24h (day then night)
+        # db/dt
+        ẋ[3](t) == ((μ2m * s(t) / (s(t) + Ks)) - u(t) * β) * b(t)
 
-    # growth model MONOD
-    function growth(s, μ2m, Ks)
-        return μ2m * s / (s + Ks)
-    end
+        # dk/dt (Time clock)
+        ẋ[4](t) == 1
 
-    # light model: max^2 (0,sin) * μbar
-    # DAY/NIGHT CYCLE: [0,2 halfperiod] rescaled to [0,2pi]
-    function light(time, halfperiod)
-        days = time / (halfperiod * 2)
-        tau = (days - floor(days)) * 2π
-        return max(0, sin(tau))^2
+        # Objective
+        -∫((μ2m * s(t) / (s(t) + Ks)) * b(t) / (β + c)) → min
     end
 
-    # initial guess
-    init = (state=[50, 50, 50], control=0.5)
+    # --- Initial guess ---
+    init = (state = [0.15, 2.75, 1.75, t0], control = 0.5)
 
-    # discretise the optimal control problem
+    # --- Direct transcription ---
     docp = direct_transcription(
         ocp,
         description...;
-        lagrange_to_mayer=false,
-        init=init,
-        grid_size=grid_size,
-        disc_method=:trapeze,
+        lagrange_to_mayer = false,
+        init = init,
+        grid_size = grid_size,
+        disc_method = :trapeze,  # CORRECTION: :trapeze, not :trapezoid
         kwargs...,
     )
 
     return docp
-end
+end
\ No newline at end of file
diff --git a/ext/OptimalControlModels/glider.jl b/ext/OptimalControlModels/glider.jl
index d91059be..cbec4a64 100644
--- a/ext/OptimalControlModels/glider.jl
+++ b/ext/OptimalControlModels/glider.jl
@@ -110,11 +110,15 @@ function OptimalControlProblems.glider(
     end
 
     # initial guess
-    tfinit = 1
-    xinit =
-        t -> [x_t0 + vx_t0 * t / tfinit, y_t0 + t / tfinit * (y_tf - y_t0), vx_t0, vy_t0]
-    uinit = cL_max / 2
-    init = (state=xinit, control=uinit, variable=tfinit)
+    tfinit = 100.0 
+    xinit = t -> [
+        x_t0 + (t / tfinit) * 1248.0,                         
+        y_t0 + (t / tfinit) * (y_tf - y_t0),         
+        vx_t0 + (t / tfinit) * (vx_tf - vx_t0),       
+        vy_t0 + (t / tfinit) * (vy_tf - vy_t0)        
+    ]
+    uinit = 1.0
+    init = (state=xinit, control=uinit, variable=tfinit) 
 
     # discretise the optimal control problem
     docp = direct_transcription(
diff --git a/ext/OptimalControlModels/robot.jl b/ext/OptimalControlModels/robot.jl
index 1bfe831a..454ab55b 100644
--- a/ext/OptimalControlModels/robot.jl
+++ b/ext/OptimalControlModels/robot.jl
@@ -105,30 +105,42 @@ function OptimalControlProblems.robot(
         dθ(tf) == dθ_tf, (dθ_tf)
         dϕ(tf) == dϕ_tf, (dϕ_tf)
 
-        # aliases
-        I_θ = ((L - ρ(t))^3 + ρ(t)^3) * sin(ϕ(t))^2
+        
+        I_θ = ((L - ρ(t))^3 + ρ(t)^3) * (sin(ϕ(t))^2 + 1e-9)
         I_ϕ = (L - ρ(t))^3 + ρ(t)^3
 
         # dynamics  
-        ẋ(t) == [dρ(t), uρ(t) / L, dθ(t), 3 * uθ(t) / I_θ, dϕ(t), 3 * uϕ(t) / I_ϕ]
+        ẋ(t) == [dρ(t), uρ(t) / L, dθ(t), 3 * uθ(t) / I_θ, dϕ(t), 3 * uϕ(t) / I_ϕ]
 
         # objective
         tf → min
     end
 
     # initial guess
-    tf = 1
-    xinit =
-        t -> [
-            ρ_t0,
-            0,
-            2π/3 * ((t - t0) / (tf - t0))^2,
-            4π/3 * ((t - t0) / (tf - t0)),
-            ϕ_t0,
-            0,
+    tf_guess = 9.1
+    xinit = t -> begin
+        alpha = clamp((t - t0) / (tf_guess - t0), 0.0, 1.0)
+        
+        ρ_val = ρ_t0 + alpha * (ρ_tf - ρ_t0)
+        θ_val = θ_t0 + alpha * (θ_tf - θ_t0)
+        ϕ_val = ϕ_t0 + alpha * (ϕ_tf - ϕ_t0)
+
+        if abs(ϕ_val) < 1e-6
+            ϕ_val = 1e-6
+        end
+
+        return [
+            ρ_val, 
+            0.0, 
+            θ_val, 
+            0.0, 
+            ϕ_val, 
+            0.0,
         ]
-    uinit = [0, 0, 0]
-    init = (state=xinit, control=uinit, variable=tf)
+    end
+    
+    uinit = [0.0, 0.0, 0.0]
+    init = (state=xinit, control=uinit, variable=tf_guess)
 
     # discretise the optimal control problem
     docp = direct_transcription(
diff --git a/ext/OptimalControlModels/space_shuttle.jl b/ext/OptimalControlModels/space_shuttle.jl
index 2d6e6d25..bdccc605 100644
--- a/ext/OptimalControlModels/space_shuttle.jl
+++ b/ext/OptimalControlModels/space_shuttle.jl
@@ -56,8 +56,8 @@ function OptimalControlProblems.space_shuttle(
     # 
     Δt_min = params[:Δt_min]
     Δt_max = params[:Δt_max]
-    tf_l = grid_size*Δt_min
-    tf_u = grid_size*Δt_max
+    tf_l = 1500.0  #
+    tf_u = 2500.0  #
 
     ## Initial conditions
     h_t0 = params[:h_t0]
@@ -175,7 +175,7 @@ function OptimalControlProblems.space_shuttle(
     # initial guess: linear interpolation for h, v, gamma (NB. t0 = 0), constant for the rest
     # variable time step seems to be initialized at 1 in jump
     # note that ipopt will project the initial guess inside the bounds anyway.
-    tf_init = (tf_l+tf_u)/2
+    tf_init = 2000
     x_init =
         t -> [
             h_t0 + (t - t0) / (tf_init - t0) * (h_tf - h_t0),
diff --git a/ext/OptimalControlModels/steering.jl b/ext/OptimalControlModels/steering.jl
index 36aeabff..a1539e56 100644
--- a/ext/OptimalControlModels/steering.jl
+++ b/ext/OptimalControlModels/steering.jl
@@ -85,7 +85,7 @@ function OptimalControlProblems.steering(
         end
     end
     xinit = t -> [gen_x0(t, i) for i in 1:4]
-    init = (state=xinit, control=0, variable=1)
+    init = (state=xinit, control=0, variable=0.6)
 
     # discretise the optimal control problem
     docp = direct_transcription(
diff --git a/ext/OptimalControlModels_s/bioreactor_s.jl b/ext/OptimalControlModels_s/bioreactor_s.jl
new file mode 100644
index 00000000..9d08e4df
--- /dev/null
+++ b/ext/OptimalControlModels_s/bioreactor_s.jl
@@ -0,0 +1,81 @@
+"""
+$(TYPEDSIGNATURES)
+
+Constructs the **Bioreactor optimal control problem** with **fixed initial conditions**.
+"""
+function OptimalControlProblems.bioreactor_s(
+    ::OptimalControlBackend,
+    description::Symbol...;
+    grid_size::Int = grid_size_data(:bioreactor),
+    parameters::Union{Nothing,NamedTuple} = nothing,
+    kwargs...,
+)
+    # --- Parameters ---
+    params = parameters_data(:bioreactor, parameters)
+    t0, tf = params[:t0], params[:tf]
+    β, c, γ = params[:β], params[:c], params[:γ]
+    halfperiod = params[:halfperiod]
+    Ks, μ2m, μbar, r = params[:Ks], params[:μ2m], params[:μbar], params[:r]
+
+    # --- Model ---
+    ocp = @def begin
+        t ∈ [t0, tf], time
+        x ∈ R⁴, state
+        u ∈ R, control
+
+        # Coordinate aliases
+        y = x[1]
+        s = x[2]
+        b = x[3]
+        k = x[4]
+
+        # Path constraints
+        y(t) ≥ 0
+        s(t) ≥ 0
+        b(t) ≥ 1e-3
+        k(t) ≥ t0
+        k(t) ≤ tf
+
+        # Control bounds
+        0 ≤ u(t) ≤ 1
+
+        # Fixed Initial Conditions
+        y(t0) == 0.05
+        s(t0) == 0.5
+        b(t0) == 0.5
+        k(t0) == t0
+
+        # Dynamics (Coordinatewise & Inline)
+        
+        # dy/dt
+        ẋ[1](t) == (μbar * sin(k(t) * π / halfperiod)^2) * y(t) / (1 + y(t)) - (r + u(t)) * y(t)
+
+        # ds/dt
+        ẋ[2](t) == -(μ2m * s(t) / (s(t) + Ks)) * b(t) + u(t) * β * (γ * y(t) - s(t))
+
+        # db/dt
+        ẋ[3](t) == ((μ2m * s(t) / (s(t) + Ks)) - u(t) * β) * b(t)
+
+        # dk/dt
+        ẋ[4](t) == 1
+
+        # Objective
+        -∫((μ2m * s(t) / (s(t) + Ks)) * b(t) / (β + c)) → min
+    end
+
+    # --- Initial guess ---
+    init = (state = [0.05, 0.5, 0.5, t0], control = 0.5)
+
+    # --- Direct transcription ---
+    docp = direct_transcription(
+        ocp,
+        description...;
+        lagrange_to_mayer = false,
+        init = init,
+        grid_size = grid_size,
+        disc_method = :trapeze,
+        kwargs...,
+    )
+
+    return docp
+end
\ No newline at end of file
diff --git a/ext/OptimalControlModels_s/glider_s.jl b/ext/OptimalControlModels_s/glider_s.jl
index 59cd87e7..7e73c295 100644
--- a/ext/OptimalControlModels_s/glider_s.jl
+++ b/ext/OptimalControlModels_s/glider_s.jl
@@ -104,10 +104,14 @@ function OptimalControlProblems.glider_s(
     end
 
     # initial guess
-    tfinit = 1
-    xinit =
-        t -> [x_t0 + vx_t0 * t / tfinit, y_t0 + t / tfinit * (y_tf - y_t0), vx_t0, vy_t0]
-    uinit = cL_max / 2
+    tfinit = 100.0 
+    xinit = t -> [
+        x_t0 + (t / tfinit) * 1248.0,                           
+        y_t0 + (t / tfinit) * (y_tf - y_t0),         
+        vx_t0 + (t / tfinit) * (vx_tf - vx_t0),       
+        vy_t0 + (t / tfinit) * (vy_tf - vy_t0)        
+    ]
+    uinit = 1.0
     init = (state=xinit, control=uinit, variable=tfinit)
 
     # discretise the optimal control problem
diff --git a/ext/OptimalControlModels_s/robot_s.jl b/ext/OptimalControlModels_s/robot_s.jl
index 2756c18b..b9f245fe 100644
--- a/ext/OptimalControlModels_s/robot_s.jl
+++ b/ext/OptimalControlModels_s/robot_s.jl
@@ -106,7 +106,7 @@ function OptimalControlProblems.robot_s(
         dϕ(tf) == dϕ_tf, (dϕ_tf)
 
         # aliases
-        I_θ = ((L - ρ(t))^3 + ρ(t)^3) * sin(ϕ(t))^2
+        I_θ = ((L - ρ(t))^3 + ρ(t)^3) * (sin(ϕ(t))^2 + 1e-9)
         I_ϕ = (L - ρ(t))^3 + ρ(t)^3
 
         # dynamics  
@@ -122,18 +122,29 @@ function OptimalControlProblems.robot_s(
     end
 
     # initial guess
-    tf = 1
-    xinit =
-        t -> [
-            ρ_t0,
-            0,
-            2π/3 * ((t - t0) / (tf - t0))^2,
-            4π/3 * ((t - t0) / (tf - t0)),
-            ϕ_t0,
-            0,
+    tf_guess = 9.1
+    xinit = t -> begin
+        alpha = clamp((t - t0) / (tf_guess - t0), 0.0, 1.0)
+        
+        ρ_val = ρ_t0 + alpha * (ρ_tf - ρ_t0)
+        θ_val = θ_t0 + alpha * (θ_tf - θ_t0)
+        ϕ_val = ϕ_t0 + alpha * (ϕ_tf - ϕ_t0)
+
+        if abs(ϕ_val) < 1e-6
+            ϕ_val = 1e-6
+        end
+
+        return [
+            ρ_val, 
+            0.0, 
+            θ_val, 
+            0.0, 
+            ϕ_val, 
+            0.0,
         ]
-    uinit = [0, 0, 0]
-    init = (state=xinit, control=uinit, variable=tf)
+    end
+    uinit = [0.0, 0.0, 0.0]
+    init = (state=xinit, control=uinit, variable=tf_guess)
 
     # discretise the optimal control problem
     docp = direct_transcription(
diff --git a/ext/OptimalControlModels_s/space_shuttle_s.jl b/ext/OptimalControlModels_s/space_shuttle_s.jl
index f1469e0a..77b4df0e 100644
--- a/ext/OptimalControlModels_s/space_shuttle_s.jl
+++ b/ext/OptimalControlModels_s/space_shuttle_s.jl
@@ -56,8 +56,8 @@ function OptimalControlProblems.space_shuttle_s(
     # 
     Δt_min = params[:Δt_min]
     Δt_max = params[:Δt_max]
-    tf_l = grid_size*Δt_min
-    tf_u = grid_size*Δt_max
+    tf_l = 1500.0  #
+    tf_u = 2500.0  #
 
     ## Initial conditions
     h_t0 = params[:h_t0]
@@ -164,7 +164,7 @@ function OptimalControlProblems.space_shuttle_s(
     # initial guess: linear interpolation for h, v, gamma (NB. t0 = 0), constant for the rest
     # variable time step seems to be initialized at 1 in jump
     # note that ipopt will project the initial guess inside the bounds anyway.
-    tf_init = (tf_l+tf_u)/2
+    tf_init = 2000
     x_init =
         t -> [
             h_t0 + (t - t0) / (tf_init - t0) * (h_tf - h_t0),
diff --git a/ext/OptimalControlModels_s/steering_s.jl b/ext/OptimalControlModels_s/steering_s.jl
index c78da787..047c2efe 100644
--- a/ext/OptimalControlModels_s/steering_s.jl
+++ b/ext/OptimalControlModels_s/steering_s.jl
@@ -85,7 +85,7 @@ function OptimalControlProblems.steering_s(
         end
     end
     xinit = t -> [gen_x0(t, i) for i in 1:4]
-    init = (state=xinit, control=0, variable=1)
+    init = (state=xinit, control=0, variable=0.6)
 
     # discretise the optimal control problem
     docp = direct_transcription(
diff --git a/src/OptimalControlProblems.jl b/src/OptimalControlProblems.jl
index 9729407d..9cd2d443 100644
--- a/src/OptimalControlProblems.jl
+++ b/src/OptimalControlProblems.jl
@@ -68,10 +68,8 @@ function make_list_of_problems()
         :dielectrophoretic_particle,
         :moonlander,
         :ducted_fan,
-        :insurance,
-        :robot,
-        :space_shuttle,
-        :steering,
+        #:robot,
+        #:space_shuttle,
     ]
     list_of_problems = setdiff(list_of_problems, problems_to_exclude)