diff --git a/LICENSE.TXT b/LICENSE.TXT
index 82962f68e8..ee528bd48d 100644
--- a/LICENSE.TXT
+++ b/LICENSE.TXT
@@ -127,7 +127,7 @@ Copyright (C) 2016 Nicholas Bertocchi
 Copyright (C) 2016 Stefano Fondi
 Copyright (C) 2016, 2017 Fabrice Lecuyer
 Copyright (C) 2016, 2019, 2020 Eisuke Tani
-Copyright (C) 2016, 2020, 2022 Quaternion Risk Management Ltd
+Copyright (C) 2016, 2019, 2020, 2022 Quaternion Risk Management Ltd
 
 Copyright (C) 2017 BN Algorithms Ltd
 Copyright (C) 2017 Joseph Jeisman
@@ -153,11 +153,11 @@ Copyright (C) 2020 Piotr Siejda
 Copyright (C) 2020, 2021 Jack Gillett
 Copyright (C) 2020, 2021 Lew Wei Hao
 Copyright (C) 2020, 2021, 2022, 2023, 2025 Marcin Rybacki
+Copyright (C) 2020, 2021, 2022, 2023, 2024 Skandinaviska Enskilda Banken AB (publ)
 
 Copyright (C) 2021 Anubhav Pandey
 Copyright (C) 2021 Magnus Mencke
 Copyright (C) 2021, 2022, 2023, 2024 Ralf Konrad Eckel
-Copyright (C) 2021, 2022, 2023, 2024 Skandinaviska Enskilda Banken AB (publ)
 
 Copyright (C) 2022, 2023 Ignacio Anguita
 Copyright (C) 2022, 2023 Jonghee Lee
@@ -171,6 +171,7 @@ Copyright (C) 2023 Paul Xi Cao
 Copyright (C) 2024 Jacques du Toit
 Copyright (C) 2024 Jongbong An
 
+Copyright (C) 2025 AcadiaSoft Inc.
 Copyright (C) 2025 Eugene Toder
 Copyright (C) 2025 Hiroto Ogawa
 Copyright (C) 2025 Kareem Fareed
diff --git a/QuantLib.vcxproj b/QuantLib.vcxproj
index 5d040d7836..e1a989c098 100644
--- a/QuantLib.vcxproj
+++ b/QuantLib.vcxproj
@@ -1724,7 +1724,9 @@
     <ClInclude Include="ql\termstructures\volatility\equityfx\blackconstantvol.hpp" />
     <ClInclude Include="ql\termstructures\volatility\equityfx\blackvariancecurve.hpp" />
     <ClInclude Include="ql\termstructures\volatility\equityfx\blackvariancesurface.hpp" />
+    <ClInclude Include="ql\termstructures\volatility\equityfx\blackvolsurfacedelta.hpp" />
     <ClInclude Include="ql\termstructures\volatility\equityfx\blackvoltermstructure.hpp" />
+    <ClInclude Include="ql\termstructures\volatility\equityfx\blackvoltimeextrapolation.hpp" />
     <ClInclude Include="ql\termstructures\volatility\equityfx\fixedlocalvolsurface.hpp" />
     <ClInclude Include="ql\termstructures\volatility\equityfx\gridmodellocalvolsurface.hpp" />
     <ClInclude Include="ql\termstructures\volatility\equityfx\hestonblackvolsurface.hpp" />
@@ -2753,7 +2755,9 @@
     <ClCompile Include="ql\termstructures\volatility\equityfx\andreasenhugevolatilityinterpl.cpp" />
     <ClCompile Include="ql\termstructures\volatility\equityfx\blackvariancecurve.cpp" />
     <ClCompile Include="ql\termstructures\volatility\equityfx\blackvariancesurface.cpp" />
+    <ClCompile Include="ql\termstructures\volatility\equityfx\blackvolsurfacedelta.cpp" />
     <ClCompile Include="ql\termstructures\volatility\equityfx\blackvoltermstructure.cpp" />
+    <ClCompile Include="ql\termstructures\volatility\equityfx\blackvoltimeextrapolation.cpp" />
     <ClCompile Include="ql\termstructures\volatility\equityfx\fixedlocalvolsurface.cpp" />
     <ClCompile Include="ql\termstructures\volatility\equityfx\gridmodellocalvolsurface.cpp" />
     <ClCompile Include="ql\termstructures\volatility\equityfx\hestonblackvolsurface.cpp" />
diff --git a/QuantLib.vcxproj.filters b/QuantLib.vcxproj.filters
index 3e78689eed..2bb4f7a258 100644
--- a/QuantLib.vcxproj.filters
+++ b/QuantLib.vcxproj.filters
@@ -2052,9 +2052,15 @@
     <ClInclude Include="ql\termstructures\volatility\equityfx\blackvariancesurface.hpp">
       <Filter>termstructures\volatility\equityfx</Filter>
     </ClInclude>
+    <ClInclude Include="ql\termstructures\volatility\equityfx\blackvolsurfacedelta.hpp">
+      <Filter>termstructures\volatility\equityfx</Filter>
+    </ClInclude>
     <ClInclude Include="ql\termstructures\volatility\equityfx\blackvoltermstructure.hpp">
       <Filter>termstructures\volatility\equityfx</Filter>
     </ClInclude>
+    <ClInclude Include="ql\termstructures\volatility\equityfx\blackvoltimeextrapolation.hpp">
+      <Filter>termstructures\volatility\equityfx</Filter>
+    </ClInclude>
     <ClInclude Include="ql\termstructures\volatility\equityfx\impliedvoltermstructure.hpp">
       <Filter>termstructures\volatility\equityfx</Filter>
     </ClInclude>
@@ -5618,9 +5624,15 @@
     <ClCompile Include="ql\termstructures\volatility\equityfx\blackvariancesurface.cpp">
       <Filter>termstructures\volatility\equityfx</Filter>
     </ClCompile>
+    <ClCompile Include="ql\termstructures\volatility\equityfx\blackvolsurfacedelta.cpp">
+      <Filter>termstructures\volatility\equityfx</Filter>
+    </ClCompile>
     <ClCompile Include="ql\termstructures\volatility\equityfx\blackvoltermstructure.cpp">
       <Filter>termstructures\volatility\equityfx</Filter>
     </ClCompile>
+    <ClCompile Include="ql\termstructures\volatility\equityfx\blackvoltimeextrapolation.cpp">
+      <Filter>termstructures\volatility\equityfx</Filter>
+    </ClCompile>
     <ClCompile Include="ql\termstructures\volatility\equityfx\localvolsurface.cpp">
       <Filter>termstructures\volatility\equityfx</Filter>
     </ClCompile>
diff --git a/ql/CMakeLists.txt b/ql/CMakeLists.txt
index 1d41f2f1d8..2344065b83 100644
--- a/ql/CMakeLists.txt
+++ b/ql/CMakeLists.txt
@@ -833,7 +833,9 @@ set(QL_SOURCES
     termstructures/volatility/equityfx/andreasenhugevolatilityinterpl.cpp
     termstructures/volatility/equityfx/blackvariancecurve.cpp
     termstructures/volatility/equityfx/blackvariancesurface.cpp
+    termstructures/volatility/equityfx/blackvolsurfacedelta.cpp
     termstructures/volatility/equityfx/blackvoltermstructure.cpp
+    termstructures/volatility/equityfx/blackvoltimeextrapolation.cpp
     termstructures/volatility/equityfx/fixedlocalvolsurface.cpp
     termstructures/volatility/equityfx/gridmodellocalvolsurface.cpp
     termstructures/volatility/equityfx/hestonblackvolsurface.cpp
@@ -2100,7 +2102,9 @@ set(QL_HEADERS
     termstructures/volatility/equityfx/blackconstantvol.hpp
     termstructures/volatility/equityfx/blackvariancecurve.hpp
     termstructures/volatility/equityfx/blackvariancesurface.hpp
+    termstructures/volatility/equityfx/blackvolsurfacedelta.hpp
     termstructures/volatility/equityfx/blackvoltermstructure.hpp
+    termstructures/volatility/equityfx/blackvoltimeextrapolation.hpp
     termstructures/volatility/equityfx/fixedlocalvolsurface.hpp
     termstructures/volatility/equityfx/gridmodellocalvolsurface.hpp
     termstructures/volatility/equityfx/hestonblackvolsurface.hpp
diff --git a/ql/termstructures/volatility/equityfx/Makefile.am b/ql/termstructures/volatility/equityfx/Makefile.am
index 1012817aac..89e9c7ed46 100644
--- a/ql/termstructures/volatility/equityfx/Makefile.am
+++ b/ql/termstructures/volatility/equityfx/Makefile.am
@@ -10,7 +10,9 @@ this_include_HEADERS = \
     blackconstantvol.hpp \
     blackvariancecurve.hpp \
     blackvariancesurface.hpp \
+    blackvolsurfacedelta.hpp \
     blackvoltermstructure.hpp \
+    blackvoltimeextrapolation.hpp \
     fixedlocalvolsurface.hpp \
     gridmodellocalvolsurface.hpp \
     hestonblackvolsurface.hpp \
@@ -28,7 +30,9 @@ cpp_files = \
     andreasenhugevolatilityadapter.cpp \
     blackvariancecurve.cpp \
     blackvariancesurface.cpp \
+    blackvolsurfacedelta.cpp \
     blackvoltermstructure.cpp \
+    blackvoltimeextrapolation.cpp \
     fixedlocalvolsurface.cpp \
     gridmodellocalvolsurface.cpp \
     hestonblackvolsurface.cpp \
diff --git a/ql/termstructures/volatility/equityfx/all.hpp b/ql/termstructures/volatility/equityfx/all.hpp
index f3e1d195b2..7a6ae90f87 100644
--- a/ql/termstructures/volatility/equityfx/all.hpp
+++ b/ql/termstructures/volatility/equityfx/all.hpp
@@ -7,7 +7,9 @@
 #include <ql/termstructures/volatility/equityfx/blackconstantvol.hpp>
 #include <ql/termstructures/volatility/equityfx/blackvariancecurve.hpp>
 #include <ql/termstructures/volatility/equityfx/blackvariancesurface.hpp>
+#include <ql/termstructures/volatility/equityfx/blackvolsurfacedelta.hpp>
 #include <ql/termstructures/volatility/equityfx/blackvoltermstructure.hpp>
+#include <ql/termstructures/volatility/equityfx/blackvoltimeextrapolation.hpp>
 #include <ql/termstructures/volatility/equityfx/fixedlocalvolsurface.hpp>
 #include <ql/termstructures/volatility/equityfx/gridmodellocalvolsurface.hpp>
 #include <ql/termstructures/volatility/equityfx/hestonblackvolsurface.hpp>
diff --git a/ql/termstructures/volatility/equityfx/blackvariancecurve.cpp b/ql/termstructures/volatility/equityfx/blackvariancecurve.cpp
index 2a2a684705..fb131fe97f 100644
--- a/ql/termstructures/volatility/equityfx/blackvariancecurve.cpp
+++ b/ql/termstructures/volatility/equityfx/blackvariancecurve.cpp
@@ -3,6 +3,7 @@
 /*
  Copyright (C) 2002, 2003, 2004 Ferdinando Ametrano
  Copyright (C) 2003 StatPro Italia srl
+ Copyright (C) 2026 Paolo D'Elia
 
  This file is part of QuantLib, a free-software/open-source library
  for financial quantitative analysts and developers - http://quantlib.org/
@@ -28,9 +29,10 @@ namespace QuantLib {
                                            const std::vector<Date>& dates,
                                            const std::vector<Volatility>& blackVolCurve,
                                            DayCounter dayCounter,
-                                           bool forceMonotoneVariance)
+                                           bool forceMonotoneVariance,
+                                           BlackVolTimeExtrapolation::Type timeExtrapolationType)
     : BlackVarianceTermStructure(referenceDate), dayCounter_(std::move(dayCounter)),
-      maxDate_(dates.back()) {
+      maxDate_(dates.back()), timeExtrapolationType_(timeExtrapolationType) {
 
         QL_REQUIRE(dates.size()==blackVolCurve.size(),
                    "mismatch between date vector and black vol vector");
@@ -62,12 +64,11 @@ namespace QuantLib {
     }
 
     Real BlackVarianceCurve::blackVarianceImpl(Time t, Real) const {
-        if (t<=times_.back()) {
-            return varianceCurve_(t, true);
-        } else {
-            // extrapolate with flat vol
-            return varianceCurve_(times_.back(), true)*t/times_.back();
-        }
+        if (t <= times_.back())
+            return std::max(varianceCurve_(t, true), 0.0);
+        else
+            return BlackVolTimeExtrapolation::extrapolatedVariance(timeExtrapolationType_, t, times_,
+                                                                   [&](Real t){ return varianceCurve_(t, true); });
     }
 
 }
diff --git a/ql/termstructures/volatility/equityfx/blackvariancecurve.hpp b/ql/termstructures/volatility/equityfx/blackvariancecurve.hpp
index cc34f71c79..10e86b4612 100644
--- a/ql/termstructures/volatility/equityfx/blackvariancecurve.hpp
+++ b/ql/termstructures/volatility/equityfx/blackvariancecurve.hpp
@@ -3,6 +3,7 @@
 /*
  Copyright (C) 2002, 2003, 2004 Ferdinando Ametrano
  Copyright (C) 2003 StatPro Italia srl
+ Copyright (C) 2026 Paolo D'Elia
 
  This file is part of QuantLib, a free-software/open-source library
  for financial quantitative analysts and developers - http://quantlib.org/
@@ -26,6 +27,7 @@
 #define quantlib_black_variance_curve_hpp
 
 #include <ql/termstructures/volatility/equityfx/blackvoltermstructure.hpp>
+#include <ql/termstructures/volatility/equityfx/blackvoltimeextrapolation.hpp>
 #include <ql/math/interpolation.hpp>
 
 namespace QuantLib {
@@ -50,7 +52,8 @@ namespace QuantLib {
                            const std::vector<Date>& dates,
                            const std::vector<Volatility>& blackVolCurve,
                            DayCounter dayCounter,
-                           bool forceMonotoneVariance = true);
+                           bool forceMonotoneVariance = true,
+                           BlackVolTimeExtrapolation::Type timeExtrapolationType = BlackVolTimeExtrapolation::FlatVolatility);
         //! \name TermStructure interface
         //@{
         DayCounter dayCounter() const override { return dayCounter_; }
@@ -84,6 +87,7 @@ namespace QuantLib {
         std::vector<Time> times_;
         std::vector<Real> variances_;
         Interpolation varianceCurve_;
+        BlackVolTimeExtrapolation::Type timeExtrapolationType_;
     };
 
 
diff --git a/ql/termstructures/volatility/equityfx/blackvolsurfacedelta.cpp b/ql/termstructures/volatility/equityfx/blackvolsurfacedelta.cpp
new file mode 100644
index 0000000000..30e3dda780
--- /dev/null
+++ b/ql/termstructures/volatility/equityfx/blackvolsurfacedelta.cpp
@@ -0,0 +1,234 @@
+/*
+ Copyright (C) 2019 Quaternion Risk Management Ltd
+ Copyright (C) 2022 Skandinaviska Enskilda Banken AB (publ)
+ Copyright (C) 2025 Paolo D'Elia
+
+ This file is part of QuantLib, a free-software/open-source library
+ for financial quantitative analysts and developers - http://quantlib.org/
+
+ QuantLib is free software: you can redistribute it and/or modify it
+ under the terms of the QuantLib license.  You should have received a
+ copy of the license along with this program; if not, please email
+ <quantlib-dev@lists.sf.net>. The license is also available online at
+ <https://www.quantlib.org/license.shtml>.
+
+ This program is distributed in the hope that it will be useful, but WITHOUT
+ ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+ FOR A PARTICULAR PURPOSE.  See the license for more details.
+*/
+
+#include <ql/errors.hpp>
+#include <ql/quotes/simplequote.hpp>
+#include <ql/pricingengines/blackdeltacalculator.hpp>
+#include <ql/math/interpolations/cubicinterpolation.hpp>
+#include <ql/math/interpolations/linearinterpolation.hpp>
+#include <ql/termstructures/volatility/equityfx/blackvolsurfacedelta.hpp>
+#include <ql/termstructures/volatility/interpolatedsmilesection.hpp>
+#include <ql/termstructures/volatility/flatsmilesection.hpp>
+
+using namespace std;
+
+namespace QuantLib {
+
+    BlackVolatilitySurfaceDelta::BlackVolatilitySurfaceDelta(
+        Date referenceDate, const std::vector<Date>& dates, const std::vector<Real>& putDeltas,
+        const std::vector<Real>& callDeltas, bool hasAtm, const Matrix& blackVolMatrix, const DayCounter& dayCounter,
+        const Calendar& cal, const Handle<Quote>& spot, const Handle<YieldTermStructure>& domesticTS,
+        const Handle<YieldTermStructure>& foreignTS, DeltaVolQuote::DeltaType dt, DeltaVolQuote::AtmType at,
+        ext::optional<DeltaVolQuote::DeltaType> atmDeltaType, SmileInterpolationMethod im,
+        bool flatStrikeExtrapolation, BlackVolTimeExtrapolation::Type timeExtrapolationType, const Period& switchTenor,
+        DeltaVolQuote::DeltaType ltdt, DeltaVolQuote::AtmType ltat, ext::optional<DeltaVolQuote::DeltaType> longTermAtmDeltaType)
+        : BlackVolatilityTermStructure(referenceDate, cal, Following, dayCounter), dates_(dates), times_(dates.size(), 0),
+        putDeltas_(putDeltas), callDeltas_(callDeltas), hasAtm_(hasAtm), spot_(spot), domesticTS_(domesticTS),
+        foreignTS_(foreignTS), dt_(dt), at_(at), atmDeltaType_(atmDeltaType),
+        interpolationMethod_(im), flatStrikeExtrapolation_(flatStrikeExtrapolation), timeExtrapolationType_(timeExtrapolationType),
+        switchTenor_(switchTenor), ltdt_(ltdt), ltat_(ltat), longTermAtmDeltaType_(longTermAtmDeltaType) {
+
+        // If ATM delta type is not given, set it to dt
+        if (!atmDeltaType_)
+            atmDeltaType_ = dt_;
+        if (!longTermAtmDeltaType_)
+            longTermAtmDeltaType_ = ltdt_;
+
+        // set switch time
+        switchTime_ = switchTenor_ == 0 * Days ? QL_MAX_REAL : timeFromReference(optionDateFromTenor(switchTenor));
+
+        QL_REQUIRE(dates.size() > 1, "at least 1 date required");
+        // this has already been done for dates
+        for (Size i = 0; i < dates.size(); i++) {
+            QL_REQUIRE(referenceDate < dates[i], "Dates must be greater than reference date");
+            times_[i] = timeFromReference(dates[i]);
+            if (i > 0) {
+                QL_REQUIRE(times_[i] > times_[i - 1], "dates must be sorted unique!");
+            }
+        }
+
+        // check size of matrix
+        Size n = putDeltas.size() + (hasAtm ? 1 : 0) + callDeltas.size();
+        QL_REQUIRE(n > 0, "Need at least one delta");
+        QL_REQUIRE(blackVolMatrix.columns() == n, "Invalid number of columns in blackVolMatrix, got "
+                                                    << blackVolMatrix.columns() << " but have " << n << " deltas");
+        QL_REQUIRE(blackVolMatrix.rows() == dates.size(), "Invalid number of rows in blackVolMatrix, got "
+                                                            << blackVolMatrix.rows() << " but have " << dates.size()
+                                                            << " dates");
+
+        // build interpolators for each delta
+        // TODO: template this so it can be changed
+        bool forceMonotoneVariance = false;
+        for (Size i = 0; i < n; i++) {
+            vector<Volatility> vols(dates.size());
+            for (Size j = 0; j < dates.size(); j++) {
+                vols[j] = blackVolMatrix[j][i];
+            }
+
+            // BlackVarianceCurve will make a local copy of vols and dates
+            interpolators_.push_back(ext::make_shared<BlackVarianceCurve>(
+                referenceDate, dates, vols, dayCounter, forceMonotoneVariance,
+                timeExtrapolationType_));
+        }
+
+        // register
+        registerWith(spot_);
+        registerWith(domesticTS_);
+        registerWith(foreignTS_);
+    }
+
+    ext::shared_ptr<SmileSection> BlackVolatilitySurfaceDelta::blackVolSmile(Time t) const {
+
+        Real spot = spot_->value();
+        DiscountFactor dDiscount = domesticTS_->discount(t);
+        DiscountFactor fDiscount = foreignTS_->discount(t);
+        Real sqrtT = sqrt(t);
+
+        DeltaVolQuote::AtmType at;
+        DeltaVolQuote::DeltaType dt;
+        DeltaVolQuote::DeltaType atmDt;
+        if (t < switchTime_ && !close_enough(t, switchTime_)) {
+            at = at_;
+            dt = dt_;
+            atmDt = *atmDeltaType_;
+        } else {
+            at = ltat_;
+            dt = ltdt_;
+            atmDt = *longTermAtmDeltaType_;
+        }
+
+        // Store smile section in map. Use strikes as key and vols as values for automatic sorting by strike.
+        // If we have already have a strike from a previous delta, we do not overwrite it.
+        auto comp = [](Real a, Real b) { return !close(a, b) && a < b; };
+        map<Real, Real, decltype(comp)> smileSection(comp);
+        Size i = 0;
+        Real atmLevel = 1.0; // set atmLevel to 1.0 in case hasAtm_ is false
+
+        for (Real delta : putDeltas_) {
+            Real vol = interpolators_.at(i)->blackVol(t, 1, true);
+            try {
+                BlackDeltaCalculator bdc(Option::Put, dt, spot, dDiscount, fDiscount, vol * sqrtT);
+                Real strike = bdc.strikeFromDelta(delta);
+                if (smileSection.count(strike) == 0)
+                    smileSection[strike] = vol;
+            } catch (const std::exception& e) {
+                QL_FAIL("BlackVolatilitySurfaceDelta: Error during calculating put strike at delta " << delta << ": "
+                                                                                                    << e.what());
+            }
+            i++;
+        }
+        if (hasAtm_) {
+            Real vol = interpolators_.at(i)->blackVol(t, 1, true);
+            atmLevel = vol;
+            try {
+                BlackDeltaCalculator bdc(Option::Put, atmDt, spot, dDiscount, fDiscount, vol * sqrtT);
+                Real strike = bdc.atmStrike(at);
+                if (smileSection.count(strike) == 0)
+                    smileSection[strike] = vol;
+            } catch (const std::exception& e) {
+                QL_FAIL("BlackVolatilitySurfaceDelta: Error during calculating atm strike: " << e.what());
+            }
+            i++;
+        }
+        for (Real delta : callDeltas_) {
+            Real vol = interpolators_.at(i)->blackVol(t, 1, true);
+            try {
+                BlackDeltaCalculator bdc(Option::Call, dt, spot, dDiscount, fDiscount, vol * sqrtT);
+                Real strike = bdc.strikeFromDelta(delta);
+                if (smileSection.count(strike) == 0)
+                    smileSection[strike] = vol;
+            } catch (const std::exception& e) {
+                QL_FAIL("BlackVolatilitySurfaceDelta: Error during calculating call strike at delta " << delta << ": "
+                                                                                                    << e.what());
+            }
+            i++;
+        }
+
+        // sort and extract to vectors
+        vector<Real> strikes;
+        strikes.reserve(smileSection.size());
+        vector<Real> stdDevs;
+        stdDevs.reserve(smileSection.size());
+        for (const auto& kv : smileSection) {
+            strikes.push_back(kv.first);
+            stdDevs.push_back(kv.second * sqrtT);
+        }
+
+        // now build smile from strikes and vols
+        QL_REQUIRE(!stdDevs.empty(),
+                "BlackVolatilitySurfaceDelta::blackVolSmile(" << t << "): no strikes given, this is unexpected.");
+        if (stdDevs.size() == 1) {
+            // handle the situation that we only have one strike (might occur for e.g. t=0)
+            return ext::make_shared<FlatSmileSection>(t, stdDevs.front() / sqrtT, dayCounter());
+        } else {
+            // we have at least two strikes
+            if (interpolationMethod_ == SmileInterpolationMethod::Linear)
+                return ext::make_shared<InterpolatedSmileSection<Linear>>(t, strikes, stdDevs, atmLevel, Linear(), dayCounter(), 
+                                                                          VolatilityType::ShiftedLognormal, 0.0, flatStrikeExtrapolation_);
+            else if (interpolationMethod_ == SmileInterpolationMethod::NaturalCubic)
+                return ext::make_shared<InterpolatedSmileSection<Cubic>>(t, strikes, stdDevs, atmLevel, Cubic(CubicInterpolation::Kruger), 
+                                                                         dayCounter(), VolatilityType::ShiftedLognormal, 0.0, 
+                                                                         flatStrikeExtrapolation_);
+            else if (interpolationMethod_ == SmileInterpolationMethod::FinancialCubic)
+                return ext::make_shared<InterpolatedSmileSection<Cubic>>(t, 
+                        strikes, 
+                        stdDevs, 
+                        atmLevel, 
+                        Cubic(CubicInterpolation::Kruger, true, CubicInterpolation::SecondDerivative, 0.0,
+                                    CubicInterpolation::FirstDerivative),
+                        dayCounter(),
+                        VolatilityType::ShiftedLognormal, 
+                        0.0, 
+                        flatStrikeExtrapolation_);
+            else if (interpolationMethod_ == SmileInterpolationMethod::CubicSpline)
+                return ext::make_shared<InterpolatedSmileSection<Cubic>>(t, strikes, stdDevs, atmLevel, Cubic(CubicInterpolation::Spline),
+                                                                         dayCounter(), VolatilityType::ShiftedLognormal, 0.0, 
+                                                                         flatStrikeExtrapolation_);
+            else {
+                QL_FAIL("Invalid method " << (int)interpolationMethod_);
+            }
+        }
+    }
+
+    ext::shared_ptr<SmileSection> BlackVolatilitySurfaceDelta::blackVolSmile(const Date& d) const {
+        return blackVolSmile(timeFromReference(d));
+    }
+
+    Real BlackVolatilitySurfaceDelta::forward(Time t) const {
+        return spot_->value() * foreignTS_->discount(t) / domesticTS_->discount(t); // TODO
+    }
+
+    Volatility BlackVolatilitySurfaceDelta::blackVolImpl(Time t, Real strike) const {
+        // If asked for strike == 0, just return the ATM value.
+        double tme =
+            (t > times_.back() && timeExtrapolationType_ == BlackVolTimeExtrapolation::FlatVolatility) ? times_.back() : t;
+
+        if (strike == 0 || strike == Null<Real>()) {
+            if (hasAtm_) {
+                // ask the ATM interpolator directly
+                return interpolators_[putDeltas_.size()]->blackVol(tme, Null<Real>(), true);
+            } else {
+                // set strike to be fwd and we will return ATMF
+                strike = forward(tme);
+            }
+        }
+        return blackVolSmile(tme)->volatility(strike);
+    }
+
+} // namespace QuantLib
diff --git a/ql/termstructures/volatility/equityfx/blackvolsurfacedelta.hpp b/ql/termstructures/volatility/equityfx/blackvolsurfacedelta.hpp
new file mode 100644
index 0000000000..afbd5de77c
--- /dev/null
+++ b/ql/termstructures/volatility/equityfx/blackvolsurfacedelta.hpp
@@ -0,0 +1,207 @@
+/*
+ Copyright (C) 2019 Quaternion Risk Management Ltd
+ Copyright (C) 2022 Skandinaviska Enskilda Banken AB (publ)
+ Copyright (C) 2025 Paolo D'Elia
+
+ This file is part of QuantLib, a free-software/open-source library
+ for financial quantitative analysts and developers - http://quantlib.org/
+
+ QuantLib is free software: you can redistribute it and/or modify it
+ under the terms of the QuantLib license.  You should have received a
+ copy of the license along with this program; if not, please email
+ <quantlib-dev@lists.sf.net>. The license is also available online at
+ <https://www.quantlib.org/license.shtml>.
+
+ This program is distributed in the hope that it will be useful, but WITHOUT
+ ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+ FOR A PARTICULAR PURPOSE.  See the license for more details.
+*/
+
+/*! \file blackvolsurfacedelta.hpp
+ \brief Black volatility surface based on delta
+*/
+
+#ifndef quantlib_black_variance_surface_delta_hpp
+#define quantlib_black_variance_surface_delta_hpp
+
+#include <ql/quotes/deltavolquote.hpp>
+#include <ql/math/interpolation.hpp>
+#include <ql/math/matrix.hpp>
+#include <ql/termstructures/volatility/equityfx/blackvariancecurve.hpp>
+#include <ql/termstructures/volatility/equityfx/blackvoltermstructure.hpp>
+#include <ql/termstructures/yieldtermstructure.hpp>
+#include <ql/time/calendar.hpp>
+#include <ql/time/daycounter.hpp>
+#include <ql/termstructures/volatility/smilesection.hpp>
+
+namespace QuantLib {
+
+    /*! \brief Black volatility surface parameterized by market deltas
+
+        BlackVolatilitySurfaceDelta represents a Black volatility term
+        structure where market quotes are expressed as delta-based points
+        (put deltas, call deltas and optionally an ATM quote) for a set of
+        option expiries.  The surface converts the provided deltas to strikes
+        (using spot and domestic/foreign yield curves and the configured
+        delta/ATM conventions) and builds per-expiry smile sections by
+        interpolating/extrapolating the input volatility matrix.
+
+        Use-cases:
+        - Building FX/equity volatility surfaces from market delta quotes.
+        - Creating per-expiry SmileSections for pricing and risk calculations.
+    */
+    class BlackVolatilitySurfaceDelta : public BlackVolatilityTermStructure {
+    public:
+        //! Supported interpolation methods for the smile sections
+        enum class SmileInterpolationMethod { Linear, NaturalCubic, FinancialCubic, CubicSpline };
+        
+        //! \name Constructors
+        //@{
+        /*! \brief Construct a delta-parametrized Black vol surface
+            \param referenceDate    reference date for the term structure (valuation date)
+            \param dates            vector of option expiry dates (must be increasing)
+            \param putDeltas        vector of put-side deltas corresponding to matrix columns
+            \param callDeltas       vector of call-side deltas corresponding to matrix columns
+            \param hasAtm           true if an ATM column is present in the vol matrix
+            \param blackVolMatrix   matrix of Black volatilities (rows = expiries,
+                                    columns = deltas/ATM). Rows must match `dates`.
+            \param dayCounter       day-count convention used to convert dates to times
+            \param cal              calendar used for date adjustments where needed
+            \param spot             handle to spot quote (used for delta->strike conversion)
+            \param domesticTS       handle to domestic yield curve (discounting / forward)
+            \param foreignTS        handle to foreign yield curve (for FX forward)
+            \param dt               delta convention (Spot or Fwd, premium-adjusted, ...)
+            \param at               ATM convention used when extracting/constructing ATM quote
+            \param atmDeltaType     optional override delta-type for ATM computation
+            \param interpolationMethod interpolation used to build SmileSection for each expiry
+                                       can be choosen across the following interpolation methods:
+                                       Linear, NaturalCubic, FinancialCubic, CubicSpline
+            \param flatStrikeExtrapolation enable flat-vol extrapolation in strike dimension
+            \param timeExtrapolationType policy for extrapolating in time
+            \param switchTenor      tenor after which long-term delta/ATM conventions apply
+            \param ltdt             long-term delta type (used for expiries beyond switchTenor)
+            \param ltat             long-term ATM convention (used beyond switchTenor)
+            \param longTermAtmDeltaType optional override for long-term ATM delta-type
+        */
+        BlackVolatilitySurfaceDelta(Date referenceDate, const std::vector<Date>& dates, const std::vector<Real>& putDeltas,
+                                    const std::vector<Real>& callDeltas, bool hasAtm, const Matrix& blackVolMatrix,
+                                    const DayCounter& dayCounter, const Calendar& cal, const Handle<Quote>& spot,
+                                    const Handle<YieldTermStructure>& domesticTS,
+                                    const Handle<YieldTermStructure>& foreignTS,
+                                    DeltaVolQuote::DeltaType dt = DeltaVolQuote::DeltaType::Spot,
+                                    DeltaVolQuote::AtmType at = DeltaVolQuote::AtmType::AtmDeltaNeutral,
+                                    ext::optional<DeltaVolQuote::DeltaType> atmDeltaType = ext::nullopt,
+                                    SmileInterpolationMethod interpolationMethod =
+                                        SmileInterpolationMethod::Linear,
+                                    bool flatStrikeExtrapolation = false,
+                                    BlackVolTimeExtrapolation::Type timeExtrapolationType =
+                                        BlackVolTimeExtrapolation::FlatVolatility,
+                                    const Period& switchTenor = 0 * Days,
+                                    DeltaVolQuote::DeltaType ltdt = DeltaVolQuote::DeltaType::Fwd,
+                                    DeltaVolQuote::AtmType ltat = DeltaVolQuote::AtmType::AtmDeltaNeutral,
+                                    ext::optional<DeltaVolQuote::DeltaType> longTermAtmDeltaType = ext::nullopt);
+        //@}
+
+        //! \name TermStructure interface
+        //@{
+        Date maxDate() const override { return Date::maxDate(); }
+        //@}
+        //! \name VolatilityTermStructure interface
+        //@{
+        Real minStrike() const override { return 0; }
+        Real maxStrike() const override { return QL_MAX_REAL; }
+        //@}
+        //! \name Visitability
+        //@{
+        virtual void accept(AcyclicVisitor&) override;
+        //@}
+
+        //! \name Inspectors
+        //@{
+        const std::vector<Date>& dates() const { return dates_; }
+        //@}
+
+        //! Return an FxSmile for the time t
+        /*!
+          \brief Build and return a SmileSection representing the Black vol smile
+                 at time t (year fraction from the reference date).
+
+          The returned SmileSection provides volatilities as a function of strike
+          for the requested expiry time. The SmileSection is constructed from
+          the underlying delta-based surface data and the interpolation method
+          configured for this surface.
+
+          \note The produced SmileSection does not hold live references to the
+                spot or yield-term-structure handles used to construct the
+                BlackVolatilitySurfaceDelta. As a consequence, the SmileSection
+                will not update if those handles change; callers that require
+                automatic updates should recreate the SmileSection.
+
+          \param t  time to expiry expressed as a year fraction from the reference date
+          \return    a shared_ptr to a SmileSection describing the Black vol smile at time t
+
+          \throws Error if t is out of the supported time range and extrapolation
+                 is disabled.
+        */
+        ext::shared_ptr<SmileSection> blackVolSmile(Time t) const;
+
+        //! Return an FxSmile for Date d
+        /*!
+          \brief Convenience overload that resolves a calendar Date to time and
+                 returns the corresponding SmileSection.
+
+          \param d  expiry date
+          \return   a shared_ptr to a SmileSection describing the Black vol smile at date d
+
+          \throws Error if the date cannot be converted to a valid time-to-expiry
+                 or if the resulting time is out of range and extrapolation is disabled.
+        */
+        ext::shared_ptr<SmileSection> blackVolSmile(const Date& d) const;
+
+    protected:
+        virtual Volatility blackVolImpl(Time t, Real strike) const override;
+
+    private:
+        std::vector<Date> dates_;
+        std::vector<Time> times_;
+
+        std::vector<Real> putDeltas_;
+        std::vector<Real> callDeltas_;
+        bool hasAtm_;
+        std::vector<ext::shared_ptr<BlackVarianceCurve> > interpolators_;
+
+        Handle<Quote> spot_;
+        Handle<YieldTermStructure> domesticTS_;
+        Handle<YieldTermStructure> foreignTS_;
+
+        DeltaVolQuote::DeltaType dt_;
+        DeltaVolQuote::AtmType at_;
+        ext::optional<DeltaVolQuote::DeltaType> atmDeltaType_;
+
+        SmileInterpolationMethod interpolationMethod_;
+        bool flatStrikeExtrapolation_;
+        BlackVolTimeExtrapolation::Type timeExtrapolationType_;
+
+        Period switchTenor_;
+        DeltaVolQuote::DeltaType ltdt_;
+        DeltaVolQuote::AtmType ltat_;
+        ext::optional<DeltaVolQuote::DeltaType> longTermAtmDeltaType_;
+        Real switchTime_;
+
+        // calculate forward for time $t$
+        Real forward(Time t) const;
+    };
+
+    // inline definitions
+
+    inline void BlackVolatilitySurfaceDelta::accept(AcyclicVisitor& v) {
+        Visitor<BlackVolatilitySurfaceDelta>* v1 = dynamic_cast<Visitor<BlackVolatilitySurfaceDelta>*>(&v);
+        if (v1 != 0)
+            v1->visit(*this);
+        else
+            BlackVolatilityTermStructure::accept(v);
+    }
+
+} // namespace QuantLib
+
+#endif
diff --git a/ql/termstructures/volatility/equityfx/blackvoltimeextrapolation.cpp b/ql/termstructures/volatility/equityfx/blackvoltimeextrapolation.cpp
new file mode 100644
index 0000000000..74045366a8
--- /dev/null
+++ b/ql/termstructures/volatility/equityfx/blackvoltimeextrapolation.cpp
@@ -0,0 +1,96 @@
+/* -*- mode: c++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+
+/*
+ Copyright (C) 2025 AcadiaSoft Inc.
+ Copyright (C) 2026 Paolo D'Elia
+
+ This file is part of QuantLib, a free-software/open-source library
+ for financial quantitative analysts and developers - http://quantlib.org/
+
+ QuantLib is free software: you can redistribute it and/or modify it
+ under the terms of the QuantLib license.  You should have received a
+ copy of the license along with this program; if not, please email
+ <quantlib-dev@lists.sf.net>. The license is also available online at
+ <https://www.quantlib.org/license.shtml>.
+
+ This program is distributed in the hope that it will be useful, but WITHOUT
+ ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+ FOR A PARTICULAR PURPOSE.  See the license for more details.
+*/
+
+#include <ql/termstructures/volatility/equityfx/blackvoltimeextrapolation.hpp>
+#include <ql/errors.hpp>
+#include <array>
+
+namespace QuantLib {
+
+    namespace {
+
+        Real linearExtrapolation(Time t, Time t1, Time t2, Real v1, Real v2) {
+            QL_REQUIRE(t > 0.0, "t must be greater than 0.0");
+            QL_REQUIRE(t > t2, "t must be greater than times[1]");
+            QL_REQUIRE(t2 > t1, "times must be sorted");
+            QL_REQUIRE(v2 >= v1, "variances must be non-decreasing");
+            return v1 + (t - t1) * (v2 - v1) / (t2 - t1);
+        }
+
+        Real timeExtrapolationBlackVarianceFlat(Time t, Real strike, const std::vector<double>& times,
+                                                const std::function<Real(Time t, Real k)>& varianceSurface) {
+            return std::max(varianceSurface(times.back(), strike), 0.0) / times.back() * t;
+        }
+
+        Real timeExtrapolationBlackVarianceFlat(Time t, const std::vector<double>& times,
+                                                const std::function<Real(Time t)>& varianceCurve) {
+            return std::max(varianceCurve(times.back()), 0.0) / times.back() * t;
+        }
+
+        Real timeExtrapolationBlackVarianceLinear(Time t, Real strike, const std::vector<double>& times,
+                                                  const std::function<Real(Time t, Real k)>& varianceSurface) {
+            Size N = times.size();
+            Time t1 = times[N-2], t2 = times[N-1];
+            Real var1 = varianceSurface(t1, strike), var2 = varianceSurface(t2, strike);
+            return linearExtrapolation(t, t1, t2, var1, var2);
+        }
+
+        Real timeExtrapolationBlackVarianceLinear(Time t, const std::vector<double>& times,
+                                                  const std::function<Real(Time t)>& varianceCurve) {
+            Size N = times.size();
+            Time t1 = times[N-2], t2 = times[N-1];
+            Real var1 = varianceCurve(t1), var2 = varianceCurve(t2);
+            return linearExtrapolation(t, t1, t2, var1, var2);
+        }
+
+    }
+
+    Real BlackVolTimeExtrapolation::extrapolatedVariance(Type type, Time t, Real strike, const std::vector<Time>& times,
+                                                         const std::function<Real(Time t, Real k)>& varianceSurface) {
+        switch (type) {
+          case FlatVolatility:
+            return timeExtrapolationBlackVarianceFlat(t, strike, times, varianceSurface);
+          case UseInterpolator:
+            return std::max(varianceSurface(t, strike), 0.0);
+          case LinearVariance: 
+            return timeExtrapolationBlackVarianceLinear(t, strike, times, varianceSurface);
+          default:
+            QL_FAIL("unknown extrapolation type");
+        }
+    }
+
+    Real BlackVolTimeExtrapolation::extrapolatedVariance(Type type, Time t, const std::vector<Time>& times,
+                                                         const std::function<Real(Time t)>& varianceCurve) {
+        switch (type) {
+          case FlatVolatility:
+            return timeExtrapolationBlackVarianceFlat(t, times, varianceCurve);
+          case UseInterpolator:
+            return std::max(varianceCurve(t), 0.0);
+          case LinearVariance: {
+              QL_REQUIRE(times.size() >= 2, "at least two times required for volatility extrapolation");
+              return timeExtrapolationBlackVarianceLinear(t, times, varianceCurve);
+          }
+          default:
+            QL_FAIL("unknown extrapolation type");
+        }
+    }
+
+}
+
diff --git a/ql/termstructures/volatility/equityfx/blackvoltimeextrapolation.hpp b/ql/termstructures/volatility/equityfx/blackvoltimeextrapolation.hpp
new file mode 100644
index 0000000000..7f1858a633
--- /dev/null
+++ b/ql/termstructures/volatility/equityfx/blackvoltimeextrapolation.hpp
@@ -0,0 +1,62 @@
+/* -*- mode: c++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+
+/*
+ Copyright (C) 2025 AcadiaSoft Inc.
+ Copyright (C) 2026 Paolo D'Elia
+
+ This file is part of QuantLib, a free-software/open-source library
+ for financial quantitative analysts and developers - http://quantlib.org/
+
+ QuantLib is free software: you can redistribute it and/or modify it
+ under the terms of the QuantLib license.  You should have received a
+ copy of the license along with this program; if not, please email
+ <quantlib-dev@lists.sf.net>. The license is also available online at
+ <https://www.quantlib.org/license.shtml>.
+
+ This program is distributed in the hope that it will be useful, but WITHOUT
+ ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+ FOR A PARTICULAR PURPOSE.  See the license for more details.
+*/
+
+/*! \file blackvoltimeextrapolation.hpp
+    \brief Time extrapolation of Black volatility term structures
+*/
+
+#ifndef quantlib_black_vol_time_extrapolation_hpp
+#define quantlib_black_vol_time_extrapolation_hpp
+
+#include <ql/types.hpp>
+#include <functional>
+
+namespace QuantLib {
+
+    //! Time-extrapolation strategies for Black volatility term structures.
+    /*! This class provides static methods to extrapolate variance
+        beyond the maximum time of a BlackVolTermStructure, supporting both
+        surface (strike-dependent) and curve (ATM) cases.
+
+        Different extrapolation strategies are available via the Type enum.
+    */
+    class BlackVolTimeExtrapolation {
+      public:
+        //! Time-extrapolation strategy for Black volatility
+        enum Type {
+            FlatVolatility,    /*!< Flat extrapolation of the latest available volatility. */
+            UseInterpolator,   /*!< Delegate extrapolation to the underlying curve or surface,
+                                    whatever the method it uses. */
+            LinearVariance     /*!< Linear extrapolation of variance from the last two
+                                    available nodes. */
+        };
+
+        //! extrapolate a surface to a given time and strike
+        static Real extrapolatedVariance(Type type, Time t, Real strike, const std::vector<Time>& times,
+                                         const std::function<Real(Time t, Real k)>& varianceSurface);
+        //! extrapolate an ATM curve to a given time
+        static Real extrapolatedVariance(Type type, Time t, const std::vector<Time>& times,
+                                         const std::function<Real(Time t)>& varianceCurve);
+    };
+
+}
+
+
+#endif
diff --git a/ql/termstructures/volatility/interpolatedsmilesection.hpp b/ql/termstructures/volatility/interpolatedsmilesection.hpp
index 01e39caefa..9a8f5bc66a 100644
--- a/ql/termstructures/volatility/interpolatedsmilesection.hpp
+++ b/ql/termstructures/volatility/interpolatedsmilesection.hpp
@@ -47,7 +47,8 @@ namespace QuantLib {
                                  const Interpolator& interpolator = Interpolator(),
                                  const DayCounter& dc = Actual365Fixed(),
                                  VolatilityType type = ShiftedLognormal,
-                                 Real shift = 0.0);
+                                 Real shift = 0.0,
+                                 bool flatStrikeExtrapolation = false);
         InterpolatedSmileSection(Time expiryTime,
                                  std::vector<Rate> strikes,
                                  const std::vector<Real>& stdDevs,
@@ -55,7 +56,8 @@ namespace QuantLib {
                                  const Interpolator& interpolator = Interpolator(),
                                  const DayCounter& dc = Actual365Fixed(),
                                  VolatilityType type = ShiftedLognormal,
-                                 Real shift = 0.0);
+                                 Real shift = 0.0,
+                                 bool flatStrikeExtrapolation = false);
         InterpolatedSmileSection(const Date& d,
                                  std::vector<Rate> strikes,
                                  const std::vector<Handle<Quote> >& stdDevHandles,
@@ -64,7 +66,8 @@ namespace QuantLib {
                                  const Interpolator& interpolator = Interpolator(),
                                  const Date& referenceDate = Date(),
                                  VolatilityType type = ShiftedLognormal,
-                                 Real shift = 0.0);
+                                 Real shift = 0.0,
+                                 bool flatStrikeExtrapolation = false);
         InterpolatedSmileSection(const Date& d,
                                  std::vector<Rate> strikes,
                                  const std::vector<Real>& stdDevs,
@@ -73,7 +76,8 @@ namespace QuantLib {
                                  const Interpolator& interpolator = Interpolator(),
                                  const Date& referenceDate = Date(),
                                  VolatilityType type = ShiftedLognormal,
-                                 Real shift = 0.0);
+                                 Real shift = 0.0,
+                                 bool flatStrikeExtrapolation = false);
 
         void performCalculations() const override;
         Real varianceImpl(Rate strike) const override;
@@ -84,12 +88,15 @@ namespace QuantLib {
         void update() override;
 
       private:
+        void checkStrikes();
+
         Real exerciseTimeSquareRoot_;
         std::vector<Rate> strikes_;
         std::vector<Handle<Quote> > stdDevHandles_;
         Handle<Quote> atmLevel_;
         mutable std::vector<Volatility> vols_;
         mutable Interpolation interpolation_;
+        bool flatStrikeExtrapolation_;
     };
 
 
@@ -102,14 +109,18 @@ namespace QuantLib {
         const Interpolator& interpolator,
         const DayCounter& dc,
         const VolatilityType type,
-        const Real shift)
+        const Real shift,
+        bool flatStrikeExtrapolation
+    )
     : SmileSection(timeToExpiry, dc, type, shift),
       exerciseTimeSquareRoot_(std::sqrt(exerciseTime())), strikes_(std::move(strikes)),
-      stdDevHandles_(stdDevHandles), atmLevel_(std::move(atmLevel)), vols_(stdDevHandles.size()) {
+      stdDevHandles_(stdDevHandles), atmLevel_(std::move(atmLevel)), vols_(stdDevHandles.size()),
+      flatStrikeExtrapolation_(flatStrikeExtrapolation) {
         for (auto& stdDevHandle : stdDevHandles_)
             LazyObject::registerWith(stdDevHandle);
         LazyObject::registerWith(atmLevel_);
-        // check strikes!!!!!!!!!!!!!!!!!!!!
+
+        checkStrikes();
         interpolation_ = interpolator.interpolate(strikes_.begin(),
                                                   strikes_.end(),
                                                   vols_.begin());
@@ -124,10 +135,13 @@ namespace QuantLib {
         const Interpolator& interpolator,
         const DayCounter& dc,
         const VolatilityType type,
-        const Real shift)
+        const Real shift,
+        bool flatStrikeExtrapolation
+    )
     : SmileSection(timeToExpiry, dc, type, shift),
       exerciseTimeSquareRoot_(std::sqrt(exerciseTime())), strikes_(std::move(strikes)),
-      stdDevHandles_(stdDevs.size()), vols_(stdDevs.size()) {
+      stdDevHandles_(stdDevs.size()), vols_(stdDevs.size()),
+      flatStrikeExtrapolation_(flatStrikeExtrapolation) {
         // fill dummy handles to allow generic handle-based
         // computations later on
         for (Size i=0; i<stdDevs.size(); ++i)
@@ -135,7 +149,8 @@ namespace QuantLib {
                 SimpleQuote(stdDevs[i])));
         atmLevel_ = Handle<Quote>
            (ext::shared_ptr<Quote>(new SimpleQuote(atmLevel)));
-        // check strikes!!!!!!!!!!!!!!!!!!!!
+        
+        checkStrikes();
         interpolation_ = interpolator.interpolate(strikes_.begin(),
                                                   strikes_.end(),
                                                   vols_.begin());
@@ -151,14 +166,18 @@ namespace QuantLib {
         const Interpolator& interpolator,
         const Date& referenceDate,
         const VolatilityType type,
-        const Real shift)
+        const Real shift,
+        bool flatStrikeExtrapolation
+    )
     : SmileSection(d, dc, referenceDate, type, shift),
       exerciseTimeSquareRoot_(std::sqrt(exerciseTime())), strikes_(std::move(strikes)),
-      stdDevHandles_(stdDevHandles), atmLevel_(std::move(atmLevel)), vols_(stdDevHandles.size()) {
+      stdDevHandles_(stdDevHandles), atmLevel_(std::move(atmLevel)), vols_(stdDevHandles.size()),
+      flatStrikeExtrapolation_(flatStrikeExtrapolation) {
         for (auto& stdDevHandle : stdDevHandles_)
             LazyObject::registerWith(stdDevHandle);
         LazyObject::registerWith(atmLevel_);
-        // check strikes!!!!!!!!!!!!!!!!!!!!
+        
+        checkStrikes();
         interpolation_ = interpolator.interpolate(strikes_.begin(),
                                                   strikes_.end(),
                                                   vols_.begin());
@@ -174,10 +193,13 @@ namespace QuantLib {
         const Interpolator& interpolator,
         const Date& referenceDate,
         const VolatilityType type,
-        const Real shift)
+        const Real shift,
+        bool flatStrikeExtrapolation
+    )
     : SmileSection(d, dc, referenceDate, type, shift),
       exerciseTimeSquareRoot_(std::sqrt(exerciseTime())), strikes_(std::move(strikes)),
-      stdDevHandles_(stdDevs.size()), vols_(stdDevs.size()) {
+      stdDevHandles_(stdDevs.size()), vols_(stdDevs.size()),
+      flatStrikeExtrapolation_(flatStrikeExtrapolation) {
         //fill dummy handles to allow generic handle-based
         // computations later on
         for (Size i=0; i<stdDevs.size(); ++i)
@@ -185,7 +207,8 @@ namespace QuantLib {
                 SimpleQuote(stdDevs[i])));
         atmLevel_ = Handle<Quote>
            (ext::shared_ptr<Quote>(new SimpleQuote(atmLevel)));
-        // check strikes!!!!!!!!!!!!!!!!!!!!
+        
+        checkStrikes();
         interpolation_ = interpolator.interpolate(strikes_.begin(),
                                                   strikes_.end(),
                                                   vols_.begin());
@@ -204,14 +227,23 @@ namespace QuantLib {
     template <class Interpolator>
     Real InterpolatedSmileSection<Interpolator>::varianceImpl(Real strike) const {
         calculate();
-        Real v = interpolation_(strike, true);
-        return v*v*exerciseTime();
+        Real v = volatilityImpl(strike);
+        return v * v * exerciseTime();
     }
 
     template <class Interpolator>
     Real InterpolatedSmileSection<Interpolator>::volatilityImpl(Real strike) const {
         calculate();
-        return interpolation_(strike, true);
+        
+        if (flatStrikeExtrapolation_) {
+            if (strike < minStrike()) {
+                return interpolation_(minStrike(), true);                
+            } else if (strike > maxStrike()) {
+                return interpolation_(maxStrike(), true);
+            }
+        }
+
+        return std::max(interpolation_(strike, true), 0.0);
     }
 
     template <class Interpolator>
@@ -221,6 +253,12 @@ namespace QuantLib {
     }
     #endif
 
+    template <class Interpolator>
+    void InterpolatedSmileSection<Interpolator>::checkStrikes() {
+        QL_REQUIRE(std::is_sorted(strikes_.begin(), strikes_.end()), 
+                    "Strikes have to be sorted in ascending order");
+    }
+
 }
 
 #endif
diff --git a/test-suite/CMakeLists.txt b/test-suite/CMakeLists.txt
index 1a611809af..d45760bad5 100644
--- a/test-suite/CMakeLists.txt
+++ b/test-suite/CMakeLists.txt
@@ -17,6 +17,7 @@ set(QL_TEST_SOURCES
     blackdeltacalculator.cpp
 	blackcalculator.cpp
     blackformula.cpp
+    blackvolsurfacedelta.cpp
     bondforward.cpp
     bonds.cpp
     brownianbridge.cpp
@@ -90,6 +91,7 @@ set(QL_TEST_SOURCES
     instruments.cpp
     integrals.cpp
     interestrates.cpp
+    interpolatedsmilesection.cpp
     interpolations.cpp
     jumpdiffusion.cpp
     lazyobject.cpp
diff --git a/test-suite/Makefile.am b/test-suite/Makefile.am
index c326710d85..bc5701f0d3 100644
--- a/test-suite/Makefile.am
+++ b/test-suite/Makefile.am
@@ -18,6 +18,7 @@ QL_TEST_SRCS = \
 	blackcalculator.cpp \
 	blackdeltacalculator.cpp \
 	blackformula.cpp \
+	blackvolsurfacedelta.cpp \
 	bondforward.cpp \
 	bonds.cpp \
 	brownianbridge.cpp \
@@ -91,6 +92,7 @@ QL_TEST_SRCS = \
 	instruments.cpp \
 	integrals.cpp \
 	interestrates.cpp \
+	interpolatedsmilesection.cpp \
 	interpolations.cpp \
 	jumpdiffusion.cpp \
 	lazyobject.cpp \
diff --git a/test-suite/blackvolsurfacedelta.cpp b/test-suite/blackvolsurfacedelta.cpp
new file mode 100644
index 0000000000..f43cdaa0ef
--- /dev/null
+++ b/test-suite/blackvolsurfacedelta.cpp
@@ -0,0 +1,297 @@
+/*
+ Copyright (C) 2019 Quaternion Risk Management Ltd
+ Copyright (C) 2020 Skandinaviska Enskilda Banken AB (publ)
+ Copyright (C) 2025 Paolo D'Elia
+
+ This file is part of QuantLib, a free-software/open-source library
+ for financial quantitative analysts and developers - http://quantlib.org/
+
+ QuantLib is free software: you can redistribute it and/or modify it
+ under the terms of the QuantLib license.  You should have received a
+ copy of the license along with this program; if not, please email
+ <quantlib-dev@lists.sf.net>. The license is also available online at
+ <https://www.quantlib.org/license.shtml>.
+
+ This program is distributed in the hope that it will be useful, but WITHOUT
+ ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+ FOR A PARTICULAR PURPOSE.  See the license for more details.
+*/
+
+#include "toplevelfixture.hpp"
+#include <boost/make_shared.hpp>
+#include <boost/test/unit_test.hpp>
+#include <ql/quotes/simplequote.hpp>
+#include <ql/termstructures/yield/flatforward.hpp>
+#include <ql/time/calendars/target.hpp>
+#include <ql/time/daycounters/actualactual.hpp>
+#include <ql/termstructures/volatility/equityfx/blackvolsurfacedelta.hpp>
+
+using namespace boost::unit_test_framework;
+using namespace QuantLib;
+using namespace std;
+
+BOOST_FIXTURE_TEST_SUITE(QuantLibTests, TopLevelFixture)
+
+BOOST_AUTO_TEST_SUITE(BlackVolSurfaceDeltaTest)
+
+BOOST_AUTO_TEST_CASE(testBlackVolSurfaceDeltaConstantVol) {
+
+    BOOST_TEST_MESSAGE("Testing BlackVolatilitySurfaceDelta...");
+
+    Date refDate(1, Jan, 2010);
+    Settings::instance().evaluationDate() = refDate;
+
+    Volatility constVol = 0.10; // 10%
+
+    // Setup a 2x2
+    vector<Date> dates = { Date(1, Jan, 2011), Date(1, Jan, 2012) };
+    vector<Real> putDeltas = { -0.25 };
+    vector<Real> callDeltas = { 0.25 };
+    bool hasAtm = false;
+    Matrix blackVolMatrix(2, 2, constVol);
+
+    // dummy spot and zero yield curve
+    Handle<Quote> spot(ext::make_shared<SimpleQuote>(1.0));
+    Handle<YieldTermStructure> dts(ext::make_shared<FlatForward>(0, TARGET(), 0.011, ActualActual(ActualActual::ISDA)));
+    Handle<YieldTermStructure> fts(ext::make_shared<FlatForward>(0, TARGET(), 0.012, ActualActual(ActualActual::ISDA)));
+
+    // build a vol surface
+    BlackVolatilitySurfaceDelta surface(refDate, dates, putDeltas, callDeltas, hasAtm, blackVolMatrix, ActualActual(ActualActual::ISDA),
+                                        TARGET(), spot, dts, fts);
+
+    // ask for volatility at lots of points, should be constVol at every point
+    // make sure we ask for vols outside 25D and 2Y
+    for (Time t : { 0.25, 0.5, 1.0, 1.5, 2.0, 2.5, 10.0 }) {
+        for (Real k = 0.5; k < 2.0; k += 0.05) {
+            Volatility vol = surface.blackVol(t, k);
+            BOOST_CHECK_EQUAL(vol, constVol);
+        }
+    }
+}
+
+BOOST_AUTO_TEST_CASE(testBlackVolSurfaceDeltaNonConstantVol) {
+
+    BOOST_TEST_MESSAGE("Testing BlackVolatilitySurfaceDelta with non constant vol surface...");
+
+    Date refDate(1, Jan, 2010);
+    Settings::instance().evaluationDate() = refDate;
+
+    Matrix vols = {
+        {0.15, 0.13, 0.135}, // 1M
+        {0.14, 0.11, 0.125}, // 6M
+        {0.13, 0.10, 0.12}, // 1Y
+        {0.125, 0.095, 0.115}, // 2Y
+    };
+
+    // Setup a 4x3
+    vector<Date> dates = {
+        refDate + Period(1, Months),
+        refDate + Period(6, Months),
+        refDate + Period(1, Years),
+        refDate + Period(2, Years)
+    };
+    vector<Real> putDeltas = { -0.25 };
+    vector<Real> callDeltas = { 0.25 };
+    bool hasAtm = true;
+
+    // dummy spot and zero yield curve
+    Handle<Quote> spot(ext::make_shared<SimpleQuote>(1.18));
+    Handle<YieldTermStructure> dts(ext::make_shared<FlatForward>(0, TARGET(), 0.02, ActualActual(ActualActual::ISDA)));
+    Handle<YieldTermStructure> fts(ext::make_shared<FlatForward>(0, TARGET(), 0.035, ActualActual(ActualActual::ISDA)));
+
+    // build a vol surface
+    BlackVolatilitySurfaceDelta surface(refDate, dates, putDeltas, callDeltas, hasAtm, vols, ActualActual(ActualActual::ISDA),
+                                        TARGET(), spot, dts, fts);
+
+    // Testing ATM strike
+    Real atmStrike = 1.18;
+
+    // ask for volatility at 1M (present in the matrix)
+    auto smile1M = surface.blackVolSmile(refDate + Period(1, Months));
+    BOOST_CHECK_CLOSE(smile1M->volatility(atmStrike), 0.13010360399, 1e-8);
+
+    // ask for volatility at 15D (using time interpolation) should be the same as the 1M
+    auto smile15D = surface.blackVolSmile(refDate + Period(15, Days));
+    BOOST_CHECK_CLOSE(smile15D->volatility(atmStrike), 0.13007226607, 1e-8);
+
+    // ask for volatility at 3M (using time interpolation)
+    auto smile3M = surface.blackVolSmile(refDate + Period(3, Months));
+    BOOST_CHECK_CLOSE(smile3M->volatility(atmStrike), 0.115077252583, 1e-8);
+
+    // ask for volatility at 6M for "extreme" strikes (using strike extrapolation)
+    Real lowStrike = 1.10;
+    Real highStrike = 1.30;
+
+    auto smile6M = surface.blackVolSmile(refDate + Period(6, Months));
+    BOOST_CHECK_CLOSE(smile6M->volatility(lowStrike), 0.1411379628132, 1e-8);
+    BOOST_CHECK_CLOSE(smile6M->volatility(highStrike), 0.136291154962, 1e-8);
+}
+
+
+BOOST_AUTO_TEST_CASE(testTimeExtrapolation) {
+
+    BOOST_TEST_MESSAGE("Testing time extrapolation of BlackVolatilitySurfaceDelta...");
+
+    Date refDate(1, Jan, 2010);
+    Settings::instance().evaluationDate() = refDate;
+
+    Matrix vols = {
+        {0.15, 0.13, 0.135}, // 1M
+        {0.14, 0.11, 0.125}, // 6M
+        {0.13, 0.10, 0.12}, // 1Y
+        {0.125, 0.095, 0.115}, // 2Y
+    };
+
+    vector<Date> dates = {
+        refDate + Period(1, Months),
+        refDate + Period(6, Months),
+        refDate + Period(1, Years),
+        refDate + Period(2, Years)
+    };
+    vector<Real> putDeltas = { -0.25 };
+    vector<Real> callDeltas = { 0.25 };
+    bool hasAtm = true;
+    Real atmStrike = 1.18;
+
+    Handle<Quote> spot(ext::make_shared<SimpleQuote>(1.18));
+    Handle<YieldTermStructure> dts(ext::make_shared<FlatForward>(0, TARGET(), 0.02, ActualActual(ActualActual::ISDA)));
+    Handle<YieldTermStructure> fts(ext::make_shared<FlatForward>(0, TARGET(), 0.035, ActualActual(ActualActual::ISDA)));
+
+    // flat volatility extrapolation
+
+    BlackVolatilitySurfaceDelta surface1(refDate, dates, putDeltas, callDeltas, hasAtm, vols, ActualActual(ActualActual::ISDA),
+                                         TARGET(), spot, dts, fts, DeltaVolQuote::DeltaType::Spot, DeltaVolQuote::AtmType::AtmSpot,
+                                         ext::nullopt, BlackVolatilitySurfaceDelta::SmileInterpolationMethod::Linear, false,
+                                         BlackVolTimeExtrapolation::FlatVolatility);
+
+    BOOST_CHECK_CLOSE(surface1.blackVol(refDate + Period(2, Years), atmStrike), 0.095, 1e-8);
+    BOOST_CHECK_CLOSE(surface1.blackVol(refDate + Period(2, Years), atmStrike - 0.1), 0.11684859871, 1e-8);
+    BOOST_CHECK_CLOSE(surface1.blackVol(refDate + Period(2, Years), atmStrike + 0.1), 0.11438709864, 1e-8);
+    BOOST_CHECK_CLOSE(surface1.blackVol(refDate + Period(3, Years), atmStrike), 0.095, 1e-8);
+    BOOST_CHECK_CLOSE(surface1.blackVol(refDate + Period(3, Years), atmStrike - 0.1), 0.11684859871, 1e-8);
+    BOOST_CHECK_CLOSE(surface1.blackVol(refDate + Period(3, Years), atmStrike + 0.1), 0.11438709864, 1e-8);
+
+    // linear variance extrapolation
+
+    BlackVolatilitySurfaceDelta surface2(refDate, dates, putDeltas, callDeltas, hasAtm, vols, ActualActual(ActualActual::ISDA),
+                                         TARGET(), spot, dts, fts, DeltaVolQuote::DeltaType::Spot, DeltaVolQuote::AtmType::AtmSpot,
+                                         ext::nullopt, BlackVolatilitySurfaceDelta::SmileInterpolationMethod::Linear, false,
+                                         BlackVolTimeExtrapolation::LinearVariance);
+
+    BOOST_CHECK_CLOSE(surface2.blackVol(refDate + Period(2, Years), atmStrike), 0.095, 1e-8);
+    BOOST_CHECK_CLOSE(surface2.blackVol(refDate + Period(2, Years), atmStrike - 0.1), 0.11684859871, 1e-8);
+    BOOST_CHECK_CLOSE(surface2.blackVol(refDate + Period(2, Years), atmStrike + 0.1), 0.11438709864, 1e-8);
+    BOOST_CHECK_CLOSE(surface2.blackVol(refDate + Period(3, Years), atmStrike), 0.09327379053, 1e-8);
+    BOOST_CHECK_CLOSE(surface2.blackVol(refDate + Period(3, Years), atmStrike - 0.1), 0.11174756764, 1e-8);
+    BOOST_CHECK_CLOSE(surface2.blackVol(refDate + Period(3, Years), atmStrike + 0.1), 0.11128755593, 1e-8);
+
+    // delegate to underlying interpolator (also linear variance)
+
+    BlackVolatilitySurfaceDelta surface3(refDate, dates, putDeltas, callDeltas, hasAtm, vols, ActualActual(ActualActual::ISDA),
+                                         TARGET(), spot, dts, fts, DeltaVolQuote::DeltaType::Spot, DeltaVolQuote::AtmType::AtmSpot,
+                                         ext::nullopt, BlackVolatilitySurfaceDelta::SmileInterpolationMethod::Linear, false,
+                                         BlackVolTimeExtrapolation::UseInterpolator);
+    surface3.enableExtrapolation();
+
+    BOOST_CHECK_CLOSE(surface3.blackVol(refDate + Period(2, Years), atmStrike), 0.095, 1e-8);
+    BOOST_CHECK_CLOSE(surface3.blackVol(refDate + Period(2, Years), atmStrike - 0.1), 0.11684859871, 1e-8);
+    BOOST_CHECK_CLOSE(surface3.blackVol(refDate + Period(2, Years), atmStrike + 0.1), 0.11438709864, 1e-8);
+    BOOST_CHECK_CLOSE(surface3.blackVol(refDate + Period(3, Years), atmStrike), 0.09327379053, 1e-8);
+    BOOST_CHECK_CLOSE(surface3.blackVol(refDate + Period(3, Years), atmStrike - 0.1), 0.11174756764, 1e-8);
+    BOOST_CHECK_CLOSE(surface3.blackVol(refDate + Period(3, Years), atmStrike + 0.1), 0.11128755593, 1e-8);
+}
+
+
+BOOST_AUTO_TEST_CASE(testSmileInterpolation) {
+
+    BOOST_TEST_MESSAGE("Testing smile interpolation of BlackVolatilitySurfaceDelta...");
+
+    Date refDate(1, Jan, 2010);
+    Settings::instance().evaluationDate() = refDate;
+
+    Matrix vols = {
+        {0.15, 0.13, 0.135}, // 1M
+        {0.14, 0.11, 0.125}, // 6M
+        {0.13, 0.10, 0.12}, // 1Y
+        {0.125, 0.095, 0.115}, // 2Y
+    };
+
+    vector<Date> dates = {
+        refDate + Period(1, Months),
+        refDate + Period(6, Months),
+        refDate + Period(1, Years),
+        refDate + Period(2, Years)
+    };
+    vector<Real> putDeltas = { -0.25 };
+    vector<Real> callDeltas = { 0.25 };
+    bool hasAtm = true;
+    Real atmStrike = 1.18;
+
+    Handle<Quote> spot(ext::make_shared<SimpleQuote>(1.18));
+    Handle<YieldTermStructure> dts(ext::make_shared<FlatForward>(0, TARGET(), 0.02, ActualActual(ActualActual::ISDA)));
+    Handle<YieldTermStructure> fts(ext::make_shared<FlatForward>(0, TARGET(), 0.035, ActualActual(ActualActual::ISDA)));
+
+    // just cache some values to check that they're not insane and that they don't change unexpectedly
+
+    BlackVolatilitySurfaceDelta surface1(refDate, dates, putDeltas, callDeltas, hasAtm, vols, ActualActual(ActualActual::ISDA),
+                                         TARGET(), spot, dts, fts, DeltaVolQuote::DeltaType::Spot, DeltaVolQuote::AtmType::AtmSpot,
+                                         ext::nullopt, BlackVolatilitySurfaceDelta::SmileInterpolationMethod::Linear, false,
+                                         BlackVolTimeExtrapolation::FlatVolatility);
+
+    auto smile = surface1.blackVolSmile(refDate + Period(6, Months));
+    BOOST_CHECK_CLOSE(smile->volatility(atmStrike), 0.11, 1e-8);
+    BOOST_CHECK_CLOSE(smile->volatility(atmStrike - 0.1), 0.14882625471, 1e-8);
+    BOOST_CHECK_CLOSE(smile->volatility(atmStrike + 0.1), 0.13265179475, 1e-8);
+    BOOST_CHECK_CLOSE(smile->volatility(smile->minStrike() - 0.1), 0.17882625471, 1e-8);
+    BOOST_CHECK_CLOSE(smile->volatility(smile->maxStrike() + 0.1), 0.14765179475, 1e-8);
+    BOOST_CHECK_CLOSE(smile->volatility(smile->minStrike() - 0.5), 0.33413127354, 1e-8);
+    BOOST_CHECK_CLOSE(smile->volatility(smile->maxStrike() + 0.5), 0.23825897375, 1e-8);
+
+    BlackVolatilitySurfaceDelta surface2(refDate, dates, putDeltas, callDeltas, hasAtm, vols, ActualActual(ActualActual::ISDA),
+                                         TARGET(), spot, dts, fts, DeltaVolQuote::DeltaType::Spot, DeltaVolQuote::AtmType::AtmSpot,
+                                         ext::nullopt, BlackVolatilitySurfaceDelta::SmileInterpolationMethod::NaturalCubic, false,
+                                         BlackVolTimeExtrapolation::FlatVolatility);
+
+    smile = surface2.blackVolSmile(refDate + Period(6, Months));
+    BOOST_CHECK_CLOSE(smile->volatility(atmStrike), 0.11, 1e-8);
+    BOOST_CHECK_CLOSE(smile->volatility(atmStrike - 0.1), 0.15285738778, 1e-8);
+    BOOST_CHECK_CLOSE(smile->volatility(atmStrike + 0.1), 0.13548210924, 1e-8);
+    BOOST_CHECK_CLOSE(smile->volatility(smile->minStrike() - 0.1), 0.16572286711, 1e-8);
+    BOOST_CHECK_CLOSE(smile->volatility(smile->maxStrike() + 0.1), 0.13314942082, 1e-8);
+    // cubic being cubic
+    BOOST_CHECK_CLOSE(smile->volatility(smile->minStrike() - 0.5), 0.0, 1e-8);
+    BOOST_CHECK_CLOSE(smile->volatility(smile->maxStrike() + 0.5), 0.0, 1e-8);
+
+    BlackVolatilitySurfaceDelta surface3(refDate, dates, putDeltas, callDeltas, hasAtm, vols, ActualActual(ActualActual::ISDA),
+                                         TARGET(), spot, dts, fts, DeltaVolQuote::DeltaType::Spot, DeltaVolQuote::AtmType::AtmSpot,
+                                         ext::nullopt, BlackVolatilitySurfaceDelta::SmileInterpolationMethod::FinancialCubic, false,
+                                         BlackVolTimeExtrapolation::FlatVolatility);
+
+    smile = surface3.blackVolSmile(refDate + Period(6, Months));
+    BOOST_CHECK_CLOSE(smile->volatility(atmStrike), 0.11, 1e-8);
+    BOOST_CHECK_CLOSE(smile->volatility(atmStrike - 0.1), 0.15285738778, 1e-8);
+    BOOST_CHECK_CLOSE(smile->volatility(atmStrike + 0.1), 0.13548210924, 1e-8);
+    BOOST_CHECK_CLOSE(smile->volatility(smile->minStrike() - 0.1), 0.16572286711, 1e-8);
+    BOOST_CHECK_CLOSE(smile->volatility(smile->maxStrike() + 0.1), 0.13314942082, 1e-8);
+    BOOST_CHECK_CLOSE(smile->volatility(smile->minStrike() - 0.5), 0.0, 1e-8);
+    BOOST_CHECK_CLOSE(smile->volatility(smile->maxStrike() + 0.5), 0.0, 1e-8);
+
+    BlackVolatilitySurfaceDelta surface4(refDate, dates, putDeltas, callDeltas, hasAtm, vols, ActualActual(ActualActual::ISDA),
+                                         TARGET(), spot, dts, fts, DeltaVolQuote::DeltaType::Spot, DeltaVolQuote::AtmType::AtmSpot,
+                                         ext::nullopt, BlackVolatilitySurfaceDelta::SmileInterpolationMethod::CubicSpline, false,
+                                         BlackVolTimeExtrapolation::FlatVolatility);
+
+    smile = surface4.blackVolSmile(refDate + Period(6, Months));
+    BOOST_CHECK_CLOSE(smile->volatility(atmStrike), 0.11, 1e-8);
+    BOOST_CHECK_CLOSE(smile->volatility(atmStrike - 0.1), 0.15226345029, 1e-8);
+    BOOST_CHECK_CLOSE(smile->volatility(atmStrike + 0.1), 0.13619688725, 1e-8);
+    BOOST_CHECK_CLOSE(smile->volatility(smile->minStrike() - 0.1), 0.16765348886, 1e-8);
+    BOOST_CHECK_CLOSE(smile->volatility(smile->maxStrike() + 0.1), 0.12948693808, 1e-8);
+    BOOST_CHECK_CLOSE(smile->volatility(smile->minStrike() - 0.5), 0.0, 1e-8);
+    BOOST_CHECK_CLOSE(smile->volatility(smile->maxStrike() + 0.5), 0.0, 1e-8);
+
+}
+
+BOOST_AUTO_TEST_SUITE_END()
+
+BOOST_AUTO_TEST_SUITE_END()
diff --git a/test-suite/interpolatedsmilesection.cpp b/test-suite/interpolatedsmilesection.cpp
new file mode 100644
index 0000000000..c5ff938738
--- /dev/null
+++ b/test-suite/interpolatedsmilesection.cpp
@@ -0,0 +1,215 @@
+/* -*- mode: c++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+
+/*
+ Copyright (C) 2025 Paolo D'Elia
+
+ This file is part of QuantLib, a free-software/open-source library
+ for financial quantitative analysts and developers - http://quantlib.org/
+
+ QuantLib is free software: you can redistribute it and/or modify it
+ under the terms of the QuantLib license.  You should have received a
+ copy of the license along with this program; if not, please email
+ <quantlib-dev@lists.sf.net>. The license is also available online at
+ <https://www.quantlib.org/license.shtml>.
+
+ This program is distributed in the hope that it will be useful, but WITHOUT
+ ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+ FOR A PARTICULAR PURPOSE.  See the license for more details.
+*/
+#include "toplevelfixture.hpp"
+#include "utilities.hpp"
+#include <ql/termstructures/volatility/interpolatedsmilesection.hpp>
+#include <ql/math/interpolations/linearinterpolation.hpp>
+#include <ql/quotes/simplequote.hpp>
+#include <ql/time/daycounters/actual365fixed.hpp>
+
+#include <vector>
+#include <cmath>
+
+using namespace QuantLib;
+using namespace boost::unit_test_framework;
+
+BOOST_FIXTURE_TEST_SUITE(QuantLibTests, TopLevelFixture)
+
+BOOST_AUTO_TEST_SUITE(InterpolatedSmileSectionTests)
+
+// Helper for linear interpolation/extrapolation between two points
+static Real linearInterp(Real x, Real x1, Real y1, Real x2, Real y2) {
+    if (x2 == x1)
+        return y1;
+    return y1 + (y2 - y1) * ( (x - x1) / (x2 - x1) );
+}
+
+BOOST_AUTO_TEST_CASE(testInterpolationAndVariance) {
+    BOOST_TEST_MESSAGE("Testing basic behaviour of linearly interpolated smile section...");
+    // basic scenario: sorted strikes, constructor taking stdDevs (total std devs)
+    Time expiry = 0.25; // 3 months
+    Real sqrtT = std::sqrt(expiry);
+    std::vector<Rate> strikes{90.0, 100.0, 110};
+    // total std deviations (i.e., sigma * sqrt(T))
+    std::vector<Real> stdDevs{
+     0.20 * sqrtT,
+     0.15 * sqrtT,
+     0.18 * sqrtT};
+    Real atmLevel = 95.0;
+
+    auto section = ext::make_shared<InterpolatedSmileSection<Linear>>(
+        expiry, strikes, stdDevs, atmLevel
+    );
+
+    // pick an interior strike 95 between 90 and 100
+    Real strike = 95.0;
+
+    Real v90 = stdDevs[0] / sqrtT;
+    Real v100 = stdDevs[1] / sqrtT;
+    Real expectedVol = linearInterp(strike, 90.0, v90, 100.0, v100);
+
+    Real tol = 1e-12;
+    BOOST_CHECK_CLOSE(section->volatilityImpl(strike), expectedVol, tol);
+
+    // variance should be vol^2 * T
+    Real expectedVar = expectedVol * expectedVol * expiry;
+    BOOST_CHECK_CLOSE(section->varianceImpl(strike), expectedVar, tol);
+}
+
+BOOST_AUTO_TEST_CASE(testExtrapolationWhenAllowed) {
+    BOOST_TEST_MESSAGE("Testing extrapolation behavior of linearly interpolated smile section...");
+    // test extrapolation behavior when flatStrikeExtrapolation=false
+    Time expiry = 0.25;
+    Real sqrtT = std::sqrt(expiry);
+    std::vector<Rate> strikes{90.0, 100.0, 110};
+    std::vector<Real> stdDevs{
+     0.20 * sqrtT,
+     0.15 * sqrtT,
+     0.18 * sqrtT};
+    Real atmLevel = 95.0;
+
+    auto section = ext::make_shared<InterpolatedSmileSection<Linear>>(
+        expiry, strikes, stdDevs, atmLevel
+    );
+
+    // compute expected extrapolated vol at strike 80 (below min strike 90)
+    Real v90 = stdDevs[0] / sqrtT;
+    Real v100 = stdDevs[1] / sqrtT;
+    Real strikeLow = 80.0;
+    Real expectedLow = linearInterp(strikeLow, 90.0, v90, 100.0, v100);
+
+    Real tol = 1e-12;
+    BOOST_CHECK_CLOSE(section->volatilityImpl(strikeLow), expectedLow, tol);
+
+    // extrapolate above max strike, e.g., 120 using last segment 110-100
+    Real v110 = stdDevs[2] / sqrtT;
+    Real strikeHigh = 120.0;
+    // use last two points (110, v110) and (100, v100) for extrapolation;
+    // linearInterp works for extrapolation as well
+    Real expectedHigh = linearInterp(strikeHigh, 110.0, v110, 100.0, v100);
+    BOOST_CHECK_CLOSE(section->volatilityImpl(strikeHigh), expectedHigh, tol);
+}
+
+BOOST_AUTO_TEST_CASE(testHandlesUpdatePropagates) {
+    BOOST_TEST_MESSAGE("Testing that linearly interpolated smile section observes its quotes...");
+    // construct via Quote handles and verify changing the underlying quote updates the section
+    Time expiry = 0.25;
+    Real sqrtT = std::sqrt(expiry);
+    std::vector<Rate> strikes{80.0, 90.0, 100.0};
+
+    // create SimpleQuote instances
+    ext::shared_ptr<SimpleQuote> q0(new SimpleQuote(0.20 * sqrtT));
+    ext::shared_ptr<SimpleQuote> q1(new SimpleQuote(0.15 * sqrtT));
+    ext::shared_ptr<SimpleQuote> q2(new SimpleQuote(0.18 * sqrtT));
+    std::vector<Handle<Quote>> stdDevHandles;
+    stdDevHandles.emplace_back(Handle<Quote>(q0));
+    stdDevHandles.emplace_back(Handle<Quote>(q1));
+    stdDevHandles.emplace_back(Handle<Quote>(q2));
+
+    ext::shared_ptr<SimpleQuote> atm(new SimpleQuote(95.0));
+    Handle<Quote> atmHandle(atm);
+
+    auto section = ext::make_shared<InterpolatedSmileSection<Linear>>(
+        expiry, strikes, stdDevHandles, atmHandle
+    );
+
+    // current vol at 95
+    Real v90 = q1->value() / sqrtT;
+    Real v100 = q2->value() / sqrtT;
+    Real expectedBefore = linearInterp(95.0, 90.0, v90, 100.0, v100);
+
+    Real tol = 1e-12;
+    BOOST_CHECK_CLOSE(section->volatilityImpl(95.0), expectedBefore, tol);
+
+    // now change the middle quote q1 from 0.15 to 0.20
+    q1->setValue(0.20 * sqrtT);
+
+    // after changing the quote, the section should reflect the new vol
+    Real v90_after = q1->value() / sqrtT;
+    Real expectedAfter = linearInterp(95.0, 90.0, v90_after, 100.0, v100);
+    BOOST_CHECK_CLOSE(section->volatilityImpl(95.0), expectedAfter, tol);
+}
+
+BOOST_AUTO_TEST_CASE(testFlatStrikeExtrapolation) {
+    BOOST_TEST_MESSAGE("Testing flat strike extrapolation in interpolated smile section...");
+    // construct via Quote handles and verify changing the underlying quote updates the section
+    Time expiry = 0.25;
+    Real sqrtT = std::sqrt(expiry);
+    std::vector<Rate> strikes{90.0, 100.0, 110.0};
+
+    // create SimpleQuote instances
+    ext::shared_ptr<SimpleQuote> q0(new SimpleQuote(0.20 * sqrtT));
+    ext::shared_ptr<SimpleQuote> q1(new SimpleQuote(0.15 * sqrtT));
+    ext::shared_ptr<SimpleQuote> q2(new SimpleQuote(0.18 * sqrtT));
+    std::vector<Handle<Quote>> stdDevHandles;
+    stdDevHandles.emplace_back(Handle<Quote>(q0));
+    stdDevHandles.emplace_back(Handle<Quote>(q1));
+    stdDevHandles.emplace_back(Handle<Quote>(q2));
+
+    ext::shared_ptr<SimpleQuote> atm(new SimpleQuote(95.0));
+    Handle<Quote> atmHandle(atm);
+
+    auto section = ext::make_shared<InterpolatedSmileSection<Linear>>(
+        expiry, strikes, stdDevHandles, atmHandle,
+        Linear(), Actual365Fixed(), ShiftedLognormal, 0.0, true
+    );
+
+    // Check with strike lower than minStrike()
+    Real v90 = q0->value() / sqrtT;
+    Real strikeLow = 85.0;
+
+    Real tol = 1e-12;
+    BOOST_CHECK_CLOSE(section->volatilityImpl(strikeLow), v90, tol);
+
+    // Check with strike higher than maxStrike()
+    Real v110 = q2->value() / sqrtT;
+    Real strikeHigh = 120.0;
+
+    BOOST_CHECK_CLOSE(section->volatilityImpl(strikeHigh), v110, tol);
+
+    //Change minStrike vol quote and check if out-of-bounds vol is the same
+    q0->setValue(0.21 * sqrtT);
+    Real v90_after = q0->value() / sqrtT;
+    BOOST_CHECK_CLOSE(section->volatilityImpl(strikeLow), v90_after, tol);
+}
+
+BOOST_AUTO_TEST_CASE(testErrorThrowingWhenNonSortedStrikes) {
+    BOOST_TEST_MESSAGE("Testing that creation of interpolated smile section with non-sorted strikes throws...");
+    // basic scenario: sorted strikes, constructor taking stdDevs (total std devs)
+    Time expiry = 0.25; // 3 months
+    Real sqrtT = std::sqrt(expiry);
+    std::vector<Rate> strikes{90.0, 110.0, 100};
+    // total std deviations (i.e., sigma * sqrt(T))
+    std::vector<Real> stdDevs{
+     0.20 * sqrtT,
+     0.15 * sqrtT,
+     0.18 * sqrtT};
+    Real atmLevel = 95.0;
+
+    BOOST_CHECK_THROW(
+        auto section = ext::make_shared<InterpolatedSmileSection<Linear>>(
+            expiry, strikes, stdDevs, atmLevel
+        ),
+        QuantLib::Error
+    );
+}
+
+BOOST_AUTO_TEST_SUITE_END()
+
+BOOST_AUTO_TEST_SUITE_END()
diff --git a/test-suite/testsuite.vcxproj b/test-suite/testsuite.vcxproj
index 729fa158ed..d3d351e881 100644
--- a/test-suite/testsuite.vcxproj
+++ b/test-suite/testsuite.vcxproj
@@ -662,6 +662,7 @@
     <ClCompile Include="blackcalculator.cpp" />
     <ClCompile Include="blackdeltacalculator.cpp" />
     <ClCompile Include="blackformula.cpp" />
+    <ClCompile Include="blackvolsurfacedelta.cpp" /> 
     <ClCompile Include="bondforward.cpp" />
     <ClCompile Include="bonds.cpp" />
     <ClCompile Include="brownianbridge.cpp" />
@@ -735,6 +736,7 @@
     <ClCompile Include="instruments.cpp" />
     <ClCompile Include="integrals.cpp" />
     <ClCompile Include="interestrates.cpp" />
+    <ClCompile Include="interpolatedsmilesection.cpp" />
     <ClCompile Include="interpolations.cpp" />
     <ClCompile Include="jumpdiffusion.cpp" />
     <ClCompile Include="lazyobject.cpp" />
diff --git a/test-suite/testsuite.vcxproj.filters b/test-suite/testsuite.vcxproj.filters
index a85a8353cf..6c9bcb8fe7 100644
--- a/test-suite/testsuite.vcxproj.filters
+++ b/test-suite/testsuite.vcxproj.filters
@@ -50,6 +50,9 @@
     <ClCompile Include="blackformula.cpp">
       <Filter>Source Files</Filter>
     </ClCompile>
+    <ClCompile Include="blackvolsurfacedelta.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
     <ClCompile Include="bonds.cpp">
       <Filter>Source Files</Filter>
     </ClCompile>
@@ -224,6 +227,9 @@
     <ClCompile Include="interestrates.cpp">
       <Filter>Source Files</Filter>
     </ClCompile>
+    <ClCompile Include="interpolatedsmilesection.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
     <ClCompile Include="interpolations.cpp">
       <Filter>Source Files</Filter>
     </ClCompile>