A possible workaround is to set the RadControl.EnableDpiScaling property to false.
static class Program
{
    /// <summary>
    /// The main entry point for the application.
    /// </summary>
    [STAThread]
    static void Main()
    {
        RadControl.EnableDpiScaling = false;

        Application.EnableVisualStyles();
        Application.SetCompatibleTextRenderingDefault(false);
        Application.Run(new RadForm1());
    }
}

Another workaround is to mark the application as DPI-aware: https://docs.telerik.com/devtools/winforms/telerik-presentation-framework/dpi-support

Workaround:   
  Sub New()
         
        InitializeComponent()
        AddHandler RadMessageBox.Instance.LocationChanged, AddressOf MsgLocationChanged
    End Sub
    Private Sub MsgLocationChanged(sender As Object, e As EventArgs)
        RadMessageBox.Instance.Location = New Point(Me.Location.X + Me.Width / 2 - RadMessageBox.Instance.Width / 2, _
                                                    Me.Location.Y + Me.Height / 2)
    End Sub

How to reproduce: just create a RadForm, in the designer change its size and set its FormBorderStyle property to be None. When the form loads its size will be increased.

Workaround: set its MaximumSize property
this.MaximumSize = new Size(400, 80);

To reproduce: Create a RadForm, select a material theme from the ToolBox, and apply the theme to the Form. Set the size of the Form to anything simple like (300, 300) and then save and close out the Form. When you reopen the same Form it will grow to (304, 302).
Please refer to the attached gif file.

Workaround: set the size at run time.

How to reproduce:
Add a StatusStrip to the form and set the FormBorderStyle to FixedSingle, you will notice that the form can be resized using the sizing grip of the status strip

Workaround:
public partial class Form2 : RadForm
{
    public Form2()
    {
        InitializeComponent();

        this.FormBorderStyle = FormBorderStyle.FixedSingle;
    }

    protected override FormControlBehavior InitializeFormBehavior()
    {
        return new CustomRadFormBehavior(this, true);
    }
}

public class CustomRadFormBehavior : RadFormBehavior
{
    public CustomRadFormBehavior(IComponentTreeHandler treeHandler, bool shouldCreateChildren)
        : base(treeHandler, shouldCreateChildren)
    { }

    public override bool HandleWndProc(ref Message m)
    {
        if ((m.Msg) == NativeMethods.WM_NCLBUTTONDOWN)
        {

            Point screenLocation = new Point(m.LParam.ToInt32());
            Point location = this.GetMappedWindowPoint(screenLocation);

            RadElement itemUnderMouse = this.Form.ElementTree.GetElementAtPoint(location);
            MouseEventArgs args = new MouseEventArgs(Control.MouseButtons, 1, location.X, location.Y, 0);

            bool isFixed = false;
            if (this.Form != null &&
                this.Form.FormBorderStyle == FormBorderStyle.Fixed3D ||
                this.Form.FormBorderStyle == FormBorderStyle.FixedDialog ||
                this.Form.FormBorderStyle == FormBorderStyle.FixedSingle ||
                this.Form.FormBorderStyle == FormBorderStyle.FixedToolWindow)
            {
                isFixed = true;
            }

            if (isFixed &&
                itemUnderMouse != null &&
                itemUnderMouse.Enabled &&
                !object.ReferenceEquals(itemUnderMouse, (this.Form.RootElement.Children[0] as RadFormElement).TitleBar))
            {
                return true;
            }
        }

        return base.HandleWndProc(ref m);
    }
}

How to reproduce:
public partial class RadForm1 : RadForm
{
    public RadForm1()
    {
        InitializeComponent();

        this.AllowTheming = false;

        this.FormBorderStyle = FormBorderStyle.FixedSingle;
    }
}

Workaround: 
public partial class RadForm1 : RadForm
{
    public RadForm1()
    {
        InitializeComponent();

        this.AllowTheming = false;

        this.FormBorderStyle = FormBorderStyle.FixedSingle;
    }

    protected override FormControlBehavior InitializeFormBehavior()
    {
        return new MyRadFormBehavior(this, true);
    }
}

public class MyRadFormBehavior : RadFormBehavior
{
    public MyRadFormBehavior(IComponentTreeHandler treeHandler, bool shouldCreateChildren)
        : base(treeHandler, shouldCreateChildren)
    { }

    public override bool HandleWndProc(ref System.Windows.Forms.Message m)
    {
        BindingFlags bindingFlags = BindingFlags.Instance | BindingFlags.NonPublic;
        if (m.Msg == NativeMethods.WM_NCHITTEST)
        {
            typeof(RadFormBehavior).GetMethod("OnWMNCHittest", bindingFlags).Invoke(this, new object[] { m });
            return true;
        }

        if (!this.AllowTheming)
        {
            return false;
        }

        return base.HandleWndProc(ref m);
    }
}

Workaround: change all RadForms to inherit the following custom base form
public class RadFormBase : RadForm
{
    protected override void OnLoad(EventArgs e)
    {
        if (this.IsDesignMode)
        {
            this.BackColor = Color.Empty;
        }

        base.OnLoad(e);
    }

    public override Color BackColor
    {
        get
        {
            return this.ElementTree.RootElement.BackColor;
        }
        set
        {
            if (value == Color.Empty)
            {
                this.ElementTree.RootElement.ResetValue(VisualElement.BackColorProperty, ValueResetFlags.Local);
            }
            else
            {
                this.ElementTree.RootElement.BackColor = value;
            }
        }
    }
}

 Use attached to reproduce.

The exception message: "A circular control reference has been made. A control cannot be owned by or parented to itself.".

Workaround:
Do not specify the owner when showing the message box.

Use attached to reproduce.

To reproduce: run the attached sample project and refer to the screenshot.

Workaround: 
((TextPrimitive)this.FormElement.TitleBar.CaptionElement).UseCompatibleTextRendering=true; 
or set the RadForm.AllowTheming property to false.

Telerik UI overflow exception with certain pointing devices, especially the LogiTech TouchPad T650. (an Int32 somewhere needs to be an Int64?)

StackTrace:

at Telerik.WinControls.UI.RadFormBehavior.OnWMNCHittest(Message& m)
at Telerik.WinControls.UI.RadFormBehavior.HandleWndProc(Message& m)
at Telerik.WinControls.UI.RadFormControlBase.WndProc(Message& m)

Steps to reproduce: 
1. Create an application with RadForm and few controls under .Net 4.7 
2. Start the application on 4K monitor (primary screen) with high DPI (200-percent scale)
3. The form is not scaled correctly. Windows do not send the message that the scale factor is changed. 

The issue is observed when the form is initially starting on high DPI (125-percent or higher). 

Workaround:
 Sub New()

     InitializeComponent()

     AddHandler RadMessageBox.Instance.LocationChanged, AddressOf MsgLocationChanged
 End Sub
 Private Sub RadTreeView1_NodeMouseClick(sender As Object, e As Telerik.WinControls.UI.RadTreeViewEventArgs) Handles RadTreeView1.NodeMouseClick
     If RadMessageBox.Show(Me, String.Format("Change Project to {0}{1}{0}?", Chr(34), e.Node.Text), "Change Project", MessageBoxButtons.YesNo, _
                           RadMessageIcon.Question, MessageBoxDefaultButton.Button1) = Windows.Forms.DialogResult.Yes Then
     End If

 End Sub

 Private Sub MsgLocationChanged(sender As Object, e As EventArgs)
     RadMessageBox.Instance.Location = New Point(Me.Location.X + Me.Width / 2, Me.Location.Y + Me.Height / 2)
 End Sub

Steps to reproduce:

1. Build an application targeting x64 platform.

2. Setup your monitors such that one has negative coordinates.

3. Run the application and move a form to the negative coordinates space.

4. You will see a System.OverflowException.

Please refer to the attached sample project and gif file.

Workaround: set the AllowTheming property to true.

To reproduce:
public partial class RadForm1 : MyForm
{
    public RadForm1()
    {
        InitializeComponent();
    }
}
public class MyForm : RadForm
{
    public MyForm()
    {
        this.AllowTheming = false;

    }
}

Please refer to the attached sample project.

Workaround:
this.SizeChanged += RadForm1_SizeChanged;
private void RadForm1_SizeChanged(object sender, EventArgs e)
{
    if (this.WindowState == FormWindowState.Maximized  && !this.IsMdiChild)
    {
        this.Region = null;
    }
}

How to reproduce:
public partial class Form1 : Form
{
    public Form1()
    {
        InitializeComponent();

        this.IsMdiContainer = true;
    }

    private void radButton1_Click(object sender, EventArgs e)
    {
        RadForm2 form = new RadForm2();
        form.Text = "MDI Child 1";
        form.MdiParent = this;
        form.ThemeName = "Desert";
        form.Show();
    }
}

public partial class RadForm2 : Telerik.WinControls.UI.RadForm
{
    public RadForm2()
    {
        InitializeComponent();

        this.AllowTheming = false;
    }
}

Workaround: override the ProcessCaptureChangeRequested method in the MDI child form
public partial class RadForm2 : Telerik.WinControls.UI.RadForm
{
    public RadForm2()
    {
        InitializeComponent();

        this.AllowTheming = false;
    }

    protected override bool ProcessCaptureChangeRequested(RadElement element, bool capture)
    {
        if (this.FormElement == null)
        {
            return this.Capture = capture;
        }

        return base.ProcessCaptureChangeRequested(element, capture);
    }
}

How to reproduce: check video and attached project

Workaround: instead of setting the AutoScroll to true of the child form use a RadScrollablePanel

To reproduce:

1. Create a RadForm - Form1
2. Change its BackColor at design time
3. Create another RadForm - Form2 
4. Open it at design time. It is expected to have the BackColor coming from the parent form.

Workaround: Set the color in the form's constructor instead of at design time.