Let's say version 1.5.6 of my shared library (a DLL file on MS-Windows, or
an SO file on Linux), contains the following class:

    class IDevice {
        virtual char const *GetName(void) = 0;
        virtual unsigned GetType(void) = 0;
     };

Objects of the type IDevice are only ever created or destroyed inside my
library using two exported functions 'CreateDevice' and 'FreeDevice'.

Let's say there's a program called Froggy that was built to link
dynamically with v1.5.6 of my library.

Two years go by, and let's say in version 2.3.7 of my library, I make an
extension to the IDevice class. I want the old Froggy binary to continue to
work properly when at runtime it finds v2.3.7 of my library instead of
v1.5.6. That is to say, I don't want an ABI break, and I want backward
compatibility. There's two ways of achieving this, the first technique is
as follows:

   class IDevice {
    public:
        virtual char const *GetName(void) = 0;
        virtual unsigned GetType(void) = 0;
    };

    class IDevice2 : public IDevice {
    public:
        virtual void *GetInputBuffer(void) = 0;
        virtual void *GetOutputBuffer(void) = 0;
    };

All of the preexisting functions that deal with an 'IDevice' can simply
dynamic_cast to an 'IDevice2' if they need to access the buffers.

The second technique is to simply extend the original class. The second
technique is as follows:

    class IDevice {
    public:
        virtual char const *GetName(void) = 0;
        virtual unsigned GetType(void) = 0;
        virtual void *GetInputBuffer(void) = 0;
        virtual void *GetOutputBuffer(void) = 0;
    };

This won't change the size, alignment or layout of an 'IDevice' object --
it will just extend the vtable by two pointers. This isn't an ABI break.

I've recently taken over coding a big SDK library, and I see both of the
above techniques used in the existing SDK code. I prefer the second
technique as it's simpler. I'm not even sure why the first technique was
ever used -- maybe because there are some cases where the second technique
results in an ABI break (e.g. multiple inheritance or virtual inheritance
or whatever I don't know).

Now of course the Standard doesn't mention vtables, nor does it allude to
something more generic such as a 'polymorphic facilitator', but still I
wonder could we possibly standardise the extending of vtables without
inducing an ABI break?

Maybe the C++26 standard could have a paragraph something like:

 - BEGIN TEXT
Given two distinct translation units, each containing a definition of a
class named S, where the class S is defined differently in the two
translation units, and if we refer to the definition in the first
translation unit as S1, and if we refer to the definition in the second
translation unit as S2, then any object of type S2 can be safely treated as
being an object of type S1, so long as S2 is an exact replica of S1 except
for one or more of the following additions:
(1) A static member function or a static member variable
(2) A non-static member variable, so long as it comes after all of the
member variables shared with S1
(3) A non-static non-virtual member function
(4) A non-static virtual member function, so long as it comes after all of
the non-static virtual member functions shared with S1.
(5) A constructor or an overloaded operator, so long as the class's type
traits remain intact (e.g. is_nothrow_assignable)
(6) A typedef or using declaration
(7) A friend
 - END TEXT

Furthermore, the standard header <type_traits> could provide the following
new helper class:

    template<class S1, class S2>
    class std::is_abi_compatible {
        inline static constexpr bool value = . . . ;
    };

So then you can ensure at compile-time that you haven't broken the ABI, as
follows:

    #include <type_traits> // is_abi_compatible

    class IDeviceOld {
    public:
        virtual char const *GetName(void) = 0;
        virtual unsigned GetType(void) = 0;
    };

    class IDeviceNew {
    public:
        virtual char const *GetName(void) = 0;
        virtual unsigned GetType(void) = 0;
        virtual void *GetInputBuffer(void) = 0;
        virtual void *GetOutputBuffer(void) = 0;
    };

    static_assert( std::is_abi_compatible_v<IDeviceOld,IDeviceNew> );

    typedef IDeviceNew IDevice;