diff --git a/QuantLib.vcxproj b/QuantLib.vcxproj
index 366c4417e73..28771422ec2 100644
--- a/QuantLib.vcxproj
+++ b/QuantLib.vcxproj
@@ -1727,6 +1727,8 @@
     <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\blackvariancetimeextrapolation.hpp" />
+    <ClInclude Include="ql\termstructures\volatility\equityfx\blackvolsurfacedelta.hpp" />
     <ClInclude Include="ql\termstructures\volatility\equityfx\blackvoltermstructure.hpp" />
     <ClInclude Include="ql\termstructures\volatility\equityfx\fixedlocalvolsurface.hpp" />
     <ClInclude Include="ql\termstructures\volatility\equityfx\gridmodellocalvolsurface.hpp" />
@@ -2753,6 +2755,7 @@
     <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\fixedlocalvolsurface.cpp" />
     <ClCompile Include="ql\termstructures\volatility\equityfx\gridmodellocalvolsurface.cpp" />
diff --git a/QuantLib.vcxproj.filters b/QuantLib.vcxproj.filters
index 5214b5342da..3c1cc862826 100644
--- a/QuantLib.vcxproj.filters
+++ b/QuantLib.vcxproj.filters
@@ -2049,6 +2049,12 @@
     <ClInclude Include="ql\termstructures\volatility\equityfx\blackvariancesurface.hpp">
       <Filter>termstructures\volatility\equityfx</Filter>
     </ClInclude>
+    <ClInclude Include="ql\termstructures\volatility\equityfx\blackvariancetimeextrapolation.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>
@@ -5600,6 +5606,9 @@
     <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>
diff --git a/ql/CMakeLists.txt b/ql/CMakeLists.txt
index fd644d1f506..d399d99f69b 100644
--- a/ql/CMakeLists.txt
+++ b/ql/CMakeLists.txt
@@ -835,6 +835,7 @@ 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/fixedlocalvolsurface.cpp
     termstructures/volatility/equityfx/gridmodellocalvolsurface.cpp
@@ -2103,6 +2104,8 @@ set(QL_HEADERS
     termstructures/volatility/equityfx/blackconstantvol.hpp
     termstructures/volatility/equityfx/blackvariancecurve.hpp
     termstructures/volatility/equityfx/blackvariancesurface.hpp
+    termstructures/volatility/equityfx/blackvariancetimeextrapolation.hpp
+    termstructures/volatility/equityfx/blackvolsurfacedelta.hpp
     termstructures/volatility/equityfx/blackvoltermstructure.hpp
     termstructures/volatility/equityfx/fixedlocalvolsurface.hpp
     termstructures/volatility/equityfx/gridmodellocalvolsurface.hpp
diff --git a/ql/termstructures/volatility/equityfx/Makefile.am b/ql/termstructures/volatility/equityfx/Makefile.am
index 38dbbf31eb6..94ae793d063 100644
--- a/ql/termstructures/volatility/equityfx/Makefile.am
+++ b/ql/termstructures/volatility/equityfx/Makefile.am
@@ -10,6 +10,8 @@ this_include_HEADERS = \
     blackconstantvol.hpp \
     blackvariancecurve.hpp \
     blackvariancesurface.hpp \
+    blackvariancetimeextrapolation.hpp \
+    blackvolsurfacedelta.hpp \
     blackvoltermstructure.hpp \
     fixedlocalvolsurface.hpp \
     gridmodellocalvolsurface.hpp \
@@ -27,6 +29,7 @@ cpp_files = \
     andreasenhugevolatilityadapter.cpp \
     blackvariancecurve.cpp \
     blackvariancesurface.cpp \
+    blackvolsurfacedelta.cpp \
     blackvoltermstructure.cpp \
     fixedlocalvolsurface.cpp \
     gridmodellocalvolsurface.cpp \
diff --git a/ql/termstructures/volatility/equityfx/blackvariancecurve.cpp b/ql/termstructures/volatility/equityfx/blackvariancecurve.cpp
index 2a2a6847057..0047ab512e3 100644
--- a/ql/termstructures/volatility/equityfx/blackvariancecurve.cpp
+++ b/ql/termstructures/volatility/equityfx/blackvariancecurve.cpp
@@ -20,6 +20,7 @@
 
 #include <ql/math/interpolations/linearinterpolation.hpp>
 #include <ql/termstructures/volatility/equityfx/blackvariancecurve.hpp>
+#include <ql/termstructures/volatility/equityfx/blackvariancetimeextrapolation.hpp>
 #include <utility>
 
 namespace QuantLib {
@@ -28,9 +29,10 @@ namespace QuantLib {
                                            const std::vector<Date>& dates,
                                            const std::vector<Volatility>& blackVolCurve,
                                            DayCounter dayCounter,
-                                           bool forceMonotoneVariance)
+                                           bool forceMonotoneVariance,
+                                           BlackVolTimeExtrapolation timeExtrapolation)
     : BlackVarianceTermStructure(referenceDate), dayCounter_(std::move(dayCounter)),
-      maxDate_(dates.back()) {
+      maxDate_(dates.back()), timeExtrapolation_(timeExtrapolation) {
 
         QL_REQUIRE(dates.size()==blackVolCurve.size(),
                    "mismatch between date vector and black vol vector");
@@ -62,11 +64,15 @@ namespace QuantLib {
     }
 
     Real BlackVarianceCurve::blackVarianceImpl(Time t, Real) const {
-        if (t<=times_.back()) {
-            return varianceCurve_(t, true);
-        } else {
+        if (t <= times_.back() || timeExtrapolation_ == BlackVolTimeExtrapolation::UseInterpolatorVariance) {
+            return std::max(varianceCurve_(t, true), 0.0);
+        } else if (timeExtrapolation_ == BlackVolTimeExtrapolation::FlatVolatility) {
             // extrapolate with flat vol
-            return varianceCurve_(times_.back(), true)*t/times_.back();
+            return timeExtrapolatationBlackVarianceFlat(t, times_, varianceCurve_);
+        } else if (timeExtrapolation_ == BlackVolTimeExtrapolation::UseInterpolatorVolatility) {
+            return timeExtrapolatationBlackVarianceInVolatility(t, times_, varianceCurve_);
+        } else {
+            QL_FAIL("Unknown time extrapolation method");
         }
     }
 
diff --git a/ql/termstructures/volatility/equityfx/blackvariancecurve.hpp b/ql/termstructures/volatility/equityfx/blackvariancecurve.hpp
index cc34f71c79a..8b2dbf0e02a 100644
--- a/ql/termstructures/volatility/equityfx/blackvariancecurve.hpp
+++ b/ql/termstructures/volatility/equityfx/blackvariancecurve.hpp
@@ -50,7 +50,8 @@ namespace QuantLib {
                            const std::vector<Date>& dates,
                            const std::vector<Volatility>& blackVolCurve,
                            DayCounter dayCounter,
-                           bool forceMonotoneVariance = true);
+                           bool forceMonotoneVariance = true,
+                           BlackVolTimeExtrapolation timeExtrapolation = BlackVolTimeExtrapolation::FlatVolatility);
         //! \name TermStructure interface
         //@{
         DayCounter dayCounter() const override { return dayCounter_; }
@@ -84,6 +85,7 @@ namespace QuantLib {
         std::vector<Time> times_;
         std::vector<Real> variances_;
         Interpolation varianceCurve_;
+        BlackVolTimeExtrapolation timeExtrapolation_;
     };
 
 
diff --git a/ql/termstructures/volatility/equityfx/blackvariancetimeextrapolation.hpp b/ql/termstructures/volatility/equityfx/blackvariancetimeextrapolation.hpp
new file mode 100644
index 00000000000..8b31163ce4e
--- /dev/null
+++ b/ql/termstructures/volatility/equityfx/blackvariancetimeextrapolation.hpp
@@ -0,0 +1,101 @@
+/* -*- mode: c++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+
+/*
+ Copyright (C) 2025 AcadiaSoft Inc.
+
+ 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
+ <http://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 blackvariancetimeextrapolation.hpp
+    \brief Utility function for time extrapolation in Black volatility in black variance term structures
+*/
+
+#include <array>
+#include <functional>
+#include <ql/math/comparison.hpp>
+#include <ql/math/interpolation.hpp>
+#include <ql/math/interpolations/interpolation2d.hpp>
+#include <ql/math/interpolations/linearinterpolation.hpp>
+
+namespace QuantLib {
+
+    namespace detail {
+        Real linearExtrapolation(const double t, const std::array<double, 2>& times, const std::array<double, 2>& variances);
+
+        inline Real linearExtrapolation(const double t, const std::array<double, 2>& times,
+                                        const std::array<double, 2>& variances) {
+            QL_REQUIRE(t > times[1], "t must be greater than times[1]");
+            QL_REQUIRE(times[1] > times[0], "times must be sorted");
+            QL_REQUIRE(variances[1] >= variances[0], "variances must be non-decreasing");
+            std::array<double, 2> vols;
+            vols[0] = close_enough(times[0], 0.0) ? 0.0 : std::sqrt(variances[0] / times[0]);
+            vols[1] = close_enough(times[1], 0.0) ? 0.0 : std::sqrt(variances[1] / times[1]);
+            LinearInterpolation interpolation(times.begin(), times.end(), vols.begin());
+            return std::max(interpolation(t, true), 0.0);
+        }
+    } // namespace
+
+
+
+    //! Extrapolate black variance using flat vol extrapolation in time direction
+    Real timeExtrapolatationBlackVarianceFlat(const Time t, const std::vector<double>& times,
+        const Interpolation& varianceCurve);
+
+    //! Extrapolate black variance using flat vol extrapolation in time direction
+    template <typename F>
+    Real timeExtrapolatationBlackVarianceFlat(const Time t, const Real strike, const std::vector<double>& times,
+                                            const F& varianceSurface) {
+        return std::max(varianceSurface(times.back(), strike, true), 0.0) / times.back() * t;
+    }
+
+
+    //! Extrapolate black variance in vol space and time direction using interpolation
+    //! Takes black variances convert them to volatilities and then linearly extrapolates
+    //! the volatilities in time direction
+    Real timeExtrapolatationBlackVarianceInVolatility(const Time t, const std::vector<double>& times,
+        const Interpolation& varianceCurve);
+
+    //! Extrapolate black variance in vol space and time direction using interpolation
+    //! Takes black variances convert them to volatilities and then linearly extrapolates
+    //! the volatilities in time direction
+    template <typename F>
+    Real timeExtrapolatationBlackVarianceInVolatility(const Time t, const Real strike, const std::vector<double>& times,
+                                                    const F& varianceSurface) {
+        Size ind1 = times.size() - 2;
+        Size ind2 = times.size() - 1;
+        std::array<Real, 2> xs{times[ind1], times[ind2]};
+        std::array<Real, 2> variances;
+        variances[0] = varianceSurface(xs[0], strike, true);
+        variances[1] = varianceSurface(xs[1], strike, true);
+        Real v = detail::linearExtrapolation(t, xs, variances);
+        return v * v * t;
+    }
+
+    inline Real timeExtrapolatationBlackVarianceFlat(const Time t, const std::vector<double>& times,
+                                                    const Interpolation& varianceCurve) {
+        return std::max(varianceCurve(times.back(), true), 0.0) / times.back() * t;
+    }
+
+    inline Real timeExtrapolatationBlackVarianceInVolatility(const Time t, const std::vector<double>& times,
+                                                            const Interpolation& varianceCurve) {
+        Size ind1 = times.size() - 2;
+        Size ind2 = times.size() - 1;
+        std::array<Real, 2> xs{times[ind1], times[ind2]};
+        std::array<Real, 2> variances;
+        variances[0] = varianceCurve(xs[0], true);
+        variances[1] = varianceCurve(xs[1], true);
+        Real v = detail::linearExtrapolation(t, xs, variances);
+        return v * v * t;
+    }
+} // namespace QuantLib
\ No newline at end of file
diff --git a/ql/termstructures/volatility/equityfx/blackvolsurfacedelta.cpp b/ql/termstructures/volatility/equityfx/blackvolsurfacedelta.cpp
new file mode 100644
index 00000000000..57d52b3782b
--- /dev/null
+++ b/ql/termstructures/volatility/equityfx/blackvolsurfacedelta.cpp
@@ -0,0 +1,235 @@
+/*
+ Copyright (C) 2019 Quaternion Risk Management Ltd
+ Copyright (C) 2022 Skandinaviska Enskilda Banken AB (publ)
+ Copyright (C) 2025 Paolo D'Elia
+ All rights reserved.
+
+ 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/experimental/fx/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, const Period& switchTenor, DeltaVolQuote::DeltaType ltdt,
+        DeltaVolQuote::AtmType ltat, ext::optional<DeltaVolQuote::DeltaType> longTermAtmDeltaType,
+        SmileInterpolationMethod im, bool flatStrikeExtrapolation, BlackVolTimeExtrapolation timeExtrapolation)
+        : 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), switchTenor_(switchTenor), ltdt_(ltdt),
+        ltat_(ltat), longTermAtmDeltaType_(longTermAtmDeltaType), interpolationMethod_(im),
+        flatStrikeExtrapolation_(flatStrikeExtrapolation), timeExtrapolation_(timeExtrapolation) {
+
+        // 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,
+                timeExtrapolation));
+        }
+
+        // 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() && timeExtrapolation_ == 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 00000000000..802fff0e1d7
--- /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
+ All rights reserved.
+
+ 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/experimental/fx/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 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
+            \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 timeExtrapolation policy for extrapolating/interpolating in time
+        */
+        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,
+                                    const Period& switchTenor = 0 * Days,
+                                    DeltaVolQuote::DeltaType ltdt = DeltaVolQuote::DeltaType::Fwd,
+                                    DeltaVolQuote::AtmType ltat = DeltaVolQuote::AtmType::AtmDeltaNeutral,
+                                    ext::optional<DeltaVolQuote::DeltaType> longTermAtmDeltaType = ext::nullopt,
+                                    SmileInterpolationMethod interpolationMethod =
+                                        SmileInterpolationMethod::Linear,
+                                    bool flatStrikeExtrapolation = false,
+                                    BlackVolTimeExtrapolation timeExtrapolation =
+                                        BlackVolTimeExtrapolation::FlatVolatility);
+        //@}
+
+        //! \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_;
+        Period switchTenor_;
+        DeltaVolQuote::DeltaType ltdt_;
+        DeltaVolQuote::AtmType ltat_;
+        ext::optional<DeltaVolQuote::DeltaType> longTermAtmDeltaType_;
+
+        SmileInterpolationMethod interpolationMethod_;
+        bool flatStrikeExtrapolation_;
+        BlackVolTimeExtrapolation timeExtrapolation_;
+        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/blackvoltermstructure.hpp b/ql/termstructures/volatility/equityfx/blackvoltermstructure.hpp
index 7c09145b532..83ae1d1df20 100644
--- a/ql/termstructures/volatility/equityfx/blackvoltermstructure.hpp
+++ b/ql/termstructures/volatility/equityfx/blackvoltermstructure.hpp
@@ -30,6 +30,12 @@
 
 namespace QuantLib {
 
+    enum class BlackVolTimeExtrapolation {
+        FlatVolatility,
+        UseInterpolatorVariance,
+        UseInterpolatorVolatility,
+    };
+
     //! Black-volatility term structure
     /*! This abstract class defines the interface of concrete
         Black-volatility term structures which will be derived from
diff --git a/ql/termstructures/volatility/interpolatedsmilesection.hpp b/ql/termstructures/volatility/interpolatedsmilesection.hpp
index 01e39caefa2..f50a56c0222 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());
@@ -205,12 +228,30 @@ namespace QuantLib {
     Real InterpolatedSmileSection<Interpolator>::varianceImpl(Real strike) const {
         calculate();
         Real v = interpolation_(strike, true);
-        return v*v*exerciseTime();
+
+        if (flatStrikeExtrapolation_) {
+            if (strike < minStrike()) {
+                v = interpolation_(minStrike(), true);                
+            } else if (strike > maxStrike()) {
+                v = interpolation_(maxStrike(), true);
+            }
+        }
+
+        return v * v * exerciseTime();
     }
 
     template <class Interpolator>
     Real InterpolatedSmileSection<Interpolator>::volatilityImpl(Real strike) const {
         calculate();
+        
+        if (flatStrikeExtrapolation_) {
+            if (strike < minStrike()) {
+                return interpolation_(minStrike(), true);                
+            } else if (strike > maxStrike()) {
+                return interpolation_(maxStrike(), true);
+            }
+        }
+
         return interpolation_(strike, true);
     }
 
@@ -221,6 +262,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 0a3ca245113..930289d32e5 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 b275faf9a8e..fbcb3c0a4a0 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 00000000000..f715c57e783
--- /dev/null
+++ b/test-suite/blackvolsurfacedelta.cpp
@@ -0,0 +1,142 @@
+/*
+ Copyright (C) 2019 Quaternion Risk Management Ltd
+ Copyright (C) 2020 Skandinaviska Enskilda Banken AB (publ)
+ Copyright (C) 2025 Paolo D'Elia
+ All rights reserved.
+
+ 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...");
+
+    Volatility constVol = 0.10; // 10%
+
+    Date refDate(1, Jan, 2010);
+    Settings::instance().evaluationDate() = refDate;
+
+    // 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
+    BOOST_TEST_MESSAGE("Build 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...");
+
+    std::vector<std::vector<Volatility>> 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
+    };
+
+    Date refDate(1, Jan, 2010);
+    Settings::instance().evaluationDate() = refDate;
+
+    // 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;
+    Matrix blackVolMatrix(4, 3);
+
+    for (Size i = 0; i < vols.size(); ++i) {
+        for (Size j = 0; j < vols.at(0).size(); ++j) {
+            blackVolMatrix[i][j] = vols[i][j];
+        }
+    }
+
+    // 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
+    BOOST_TEST_MESSAGE("Build Surface");
+    BlackVolatilitySurfaceDelta surface(refDate, dates, putDeltas, callDeltas, hasAtm, blackVolMatrix, 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 extrapolation) 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 extrapolation)
+    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_SUITE_END()
+
+BOOST_AUTO_TEST_SUITE_END()
diff --git a/test-suite/interpolatedsmilesection.cpp b/test-suite/interpolatedsmilesection.cpp
new file mode 100644
index 00000000000..a6adcfdb875
--- /dev/null
+++ b/test-suite/interpolatedsmilesection.cpp
@@ -0,0 +1,206 @@
+/* -*- 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 Linear Interpolated Smile Section");
+    // basic scenario: sorted strikes, constructor taking stdDevs (total std devs)
+    Time expiry = 0.25; // 3 months
+    std::vector<Rate> strikes{90.0, 100.0, 110};
+    // total std deviations (i.e., sigma * sqrt(T))
+    std::vector<Real> stdDevs{0.20, 0.15, 0.18};
+    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;
+
+    // vols stored internally are stdDev / sqrt(T)
+    Real sqrtT = std::sqrt(expiry);
+    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 Linear Interpolated Smile Section");
+    // test extrapolation behavior when flatStrikeExtrapolation=false
+    Time expiry = 0.25;
+    std::vector<Rate> strikes{90.0, 100.0, 110};
+    std::vector<Real> stdDevs{0.20, 0.15, 0.18};
+    Real atmLevel = 95.0;
+
+    auto section = ext::make_shared<InterpolatedSmileSection<Linear>>(
+        expiry, strikes, stdDevs, atmLevel
+    );
+
+    Real sqrtT = std::sqrt(expiry);
+    // 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 construction of Linear Interpolated Smile Section using Quote Handles for vols and updating them");
+    // construct via Quote handles and verify changing the underlying quote updates the section
+    Time expiry = 0.25;
+    std::vector<Rate> strikes{80.0, 90.0, 100.0};
+
+    // create SimpleQuote instances
+    ext::shared_ptr<SimpleQuote> q0(new SimpleQuote(0.20));
+    ext::shared_ptr<SimpleQuote> q1(new SimpleQuote(0.15));
+    ext::shared_ptr<SimpleQuote> q2(new SimpleQuote(0.18));
+    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
+    );
+
+    Real sqrtT = std::sqrt(expiry);
+    // 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);
+
+    // 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;
+    std::vector<Rate> strikes{90.0, 100.0, 110.0};
+
+    // create SimpleQuote instances
+    ext::shared_ptr<SimpleQuote> q0(new SimpleQuote(0.20));
+    ext::shared_ptr<SimpleQuote> q1(new SimpleQuote(0.15));
+    ext::shared_ptr<SimpleQuote> q2(new SimpleQuote(0.18));
+    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
+    );
+
+    Real sqrtT = std::sqrt(expiry);
+    // 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);
+    Real v90_after = q0->value() / sqrtT;
+    BOOST_CHECK_CLOSE(section->volatilityImpl(strikeLow), v90_after, tol);
+}
+
+BOOST_AUTO_TEST_CASE(testErrorThrowingWhenNonSortedStrikes) {
+    BOOST_TEST_MESSAGE("Testing throwin QuantLib::Error when creating Interpolated Smile section with non-sorted strikes");
+    // basic scenario: sorted strikes, constructor taking stdDevs (total std devs)
+    Time expiry = 0.25; // 3 months
+    std::vector<Rate> strikes{90.0, 110.0, 100};
+    // total std deviations (i.e., sigma * sqrt(T))
+    std::vector<Real> stdDevs{0.20, 0.15, 0.18};
+    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 cf47e1d30c8..47e9391f62e 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 efc3dc42436..412fc2e2cd0 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>
@@ -227,6 +230,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>