diff --git a/samples/BenchmarkDotNet.Samples/IntroIntegratedExporter.cs b/samples/BenchmarkDotNet.Samples/IntroIntegratedExporter.cs
new file mode 100644
index 0000000000..b617edc1b4
--- /dev/null
+++ b/samples/BenchmarkDotNet.Samples/IntroIntegratedExporter.cs
@@ -0,0 +1,31 @@
+using BenchmarkDotNet.Attributes;
+using BenchmarkDotNet.Attributes.Exporters;
+using BenchmarkDotNet.Exporters.IntegratedExporter;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace BenchmarkDotNet.Samples
+{
+    [IntegratedExporter(IntegratedExportType.HtmlExporterWithRPlotExporter)]
+    public class IntroIntegratedExporter
+    {
+        [Benchmark]
+        public void Benchmark()
+        {
+            var result = Calculate();
+        }
+
+        private int Calculate()
+        {
+            int sum = 0;
+            for (int i = 0; i < 1000; i++)
+            {
+                sum += i;
+            }
+            return sum;
+        }
+    }
+}
diff --git a/samples/BenchmarkDotNet.Samples/IntroRPlot.cs b/samples/BenchmarkDotNet.Samples/IntroRPlot.cs
new file mode 100644
index 0000000000..6e6b258038
--- /dev/null
+++ b/samples/BenchmarkDotNet.Samples/IntroRPlot.cs
@@ -0,0 +1,39 @@
+using BenchmarkDotNet.Attributes;
+using BenchmarkDotNet.Configs;
+using BenchmarkDotNet.Exporters;
+
+
+namespace BenchmarkDotNet.Samples
+{
+    //[MemoryDiagnoser]
+    //[Config(typeof(Config))]
+    [RPlotExporter]
+    public class IntroRPlot
+    {
+        [Benchmark]
+        public void Benchmark()
+        {
+            var result = Calculate();
+        }
+
+        private int Calculate()
+        {
+            int sum = 0;
+            for (int i = 0; i < 1000; i++)
+            {
+                sum += i;
+            }
+            return sum;
+        }
+    }
+
+    public class Config : ManualConfig
+    {
+        public Config()
+        {
+            //AddExporter(CsvMeasurementsExporter.Default);
+            //AddExporter(RPlotExporter.Default);
+        }
+    }
+
+}
\ No newline at end of file
diff --git a/src/BenchmarkDotNet/Attributes/Exporters/IntegratedExporterAttribute.cs b/src/BenchmarkDotNet/Attributes/Exporters/IntegratedExporterAttribute.cs
new file mode 100644
index 0000000000..407b232435
--- /dev/null
+++ b/src/BenchmarkDotNet/Attributes/Exporters/IntegratedExporterAttribute.cs
@@ -0,0 +1,17 @@
+using BenchmarkDotNet.Exporters.IntegratedExporter;
+using System;
+using System.Collections.Generic;
+using System.Text;
+
+namespace BenchmarkDotNet.Attributes.Exporters
+{
+    public class IntegratedExporterAttribute : IntegratedExporterConfigBaseAttribute
+    {
+        protected IntegratedExporterAttribute()
+        { }
+
+        public IntegratedExporterAttribute(IntegratedExportType integratedExporterType) : base(integratedExporterType)
+        {
+        }
+    }
+}
\ No newline at end of file
diff --git a/src/BenchmarkDotNet/Attributes/Exporters/IntegratedExporterConfigBaseAttribute.cs b/src/BenchmarkDotNet/Attributes/Exporters/IntegratedExporterConfigBaseAttribute.cs
new file mode 100644
index 0000000000..155641a70b
--- /dev/null
+++ b/src/BenchmarkDotNet/Attributes/Exporters/IntegratedExporterConfigBaseAttribute.cs
@@ -0,0 +1,25 @@
+using System;
+using BenchmarkDotNet.Configs;
+using BenchmarkDotNet.Exporters.IntegratedExporter;
+using JetBrains.Annotations;
+
+namespace BenchmarkDotNet.Attributes
+{
+    [AttributeUsage(AttributeTargets.Class | AttributeTargets.Assembly)]
+    public class IntegratedExporterConfigBaseAttribute : Attribute, IConfigSource
+    {
+        // CLS-Compliant Code requires a constructor without an array in the argument list
+        [PublicAPI]
+        protected IntegratedExporterConfigBaseAttribute()
+        {
+            Config = ManualConfig.CreateEmpty();
+        }
+
+        protected IntegratedExporterConfigBaseAttribute(IntegratedExportType exporter)
+        {
+            Config = ManualConfig.CreateEmpty().SetIntegratedExporterType(exporter);
+        }
+
+        public IConfig Config { get; }
+    }
+}
\ No newline at end of file
diff --git a/src/BenchmarkDotNet/Attributes/Exporters/RPlotExporterAttribute.cs b/src/BenchmarkDotNet/Attributes/Exporters/RPlotExporterAttribute.cs
index 4b4f6d9c39..9909559e35 100644
--- a/src/BenchmarkDotNet/Attributes/Exporters/RPlotExporterAttribute.cs
+++ b/src/BenchmarkDotNet/Attributes/Exporters/RPlotExporterAttribute.cs
@@ -1,10 +1,13 @@
 using BenchmarkDotNet.Exporters;
+using System;
+using System.Collections.Generic;
 
 namespace BenchmarkDotNet.Attributes
 {
     public class RPlotExporterAttribute : ExporterConfigBaseAttribute
     {
-        public RPlotExporterAttribute() : base(DefaultExporters.RPlot)
+
+        public RPlotExporterAttribute() : base(new RPlotExporter())
         {
         }
     }
diff --git a/src/BenchmarkDotNet/Configs/ConfigExtensions.cs b/src/BenchmarkDotNet/Configs/ConfigExtensions.cs
index 5177227c2a..ec7f8e31a5 100644
--- a/src/BenchmarkDotNet/Configs/ConfigExtensions.cs
+++ b/src/BenchmarkDotNet/Configs/ConfigExtensions.cs
@@ -1,4 +1,5 @@
 using System;
+using System.Collections.Generic;
 using System.Collections.Immutable;
 using System.ComponentModel;
 using System.Globalization;
@@ -36,6 +37,7 @@ public static class ConfigExtensions
         [Obsolete("This method will soon be removed, please start using .AddExporter() instead.")]
         [EditorBrowsable(EditorBrowsableState.Never)] public static IConfig With(this IConfig config, params IExporter[] exporters) => config.AddExporter(exporters);
         [PublicAPI] public static ManualConfig AddExporter(this IConfig config, params IExporter[] exporters) => config.With(m => m.AddExporter(exporters));
+        [PublicAPI] public static ManualConfig AddIntegratedExporter(this IConfig config, List<IExporter>? dependencies, IExporter withExporter, IExporter exporter) => config.With(m => m.AddIntegratedExporter(dependencies, withExporter, exporter));
 
         [Obsolete("This method will soon be removed, please start using .AddDiagnoser() instead.")]
         [EditorBrowsable(EditorBrowsableState.Never)] public static IConfig With(this IConfig config, params IDiagnoser[] diagnosers) => config.AddDiagnoser(diagnosers);
diff --git a/src/BenchmarkDotNet/Configs/DebugConfig.cs b/src/BenchmarkDotNet/Configs/DebugConfig.cs
index 0fdda7b08d..6a11383d13 100644
--- a/src/BenchmarkDotNet/Configs/DebugConfig.cs
+++ b/src/BenchmarkDotNet/Configs/DebugConfig.cs
@@ -6,6 +6,7 @@
 using BenchmarkDotNet.Diagnosers;
 using BenchmarkDotNet.EventProcessors;
 using BenchmarkDotNet.Exporters;
+using BenchmarkDotNet.Exporters.IntegratedExporter;
 using BenchmarkDotNet.Filters;
 using BenchmarkDotNet.Jobs;
 using BenchmarkDotNet.Loggers;
@@ -58,6 +59,8 @@ public abstract class DebugConfig : IConfig
         public IEnumerable<IValidator> GetValidators() => Array.Empty<IValidator>();
         public IEnumerable<IColumnProvider> GetColumnProviders() => DefaultColumnProviders.Instance;
         public IEnumerable<IExporter> GetExporters() => Array.Empty<IExporter>();
+        public IEnumerable<IntegratedExporterData> GetIntegratedExporters() => Array.Empty<IntegratedExporterData>();
+        public IIntegratedExporter GetIntegratedExporter() => null;
         public IEnumerable<ILogger> GetLoggers() => new[] { ConsoleLogger.Default };
         public IEnumerable<IDiagnoser> GetDiagnosers() => Array.Empty<IDiagnoser>();
         public IEnumerable<IAnalyser> GetAnalysers() => Array.Empty<IAnalyser>();
diff --git a/src/BenchmarkDotNet/Configs/DefaultConfig.cs b/src/BenchmarkDotNet/Configs/DefaultConfig.cs
index b70333cc1d..291f462dcd 100644
--- a/src/BenchmarkDotNet/Configs/DefaultConfig.cs
+++ b/src/BenchmarkDotNet/Configs/DefaultConfig.cs
@@ -9,6 +9,7 @@
 using BenchmarkDotNet.EventProcessors;
 using BenchmarkDotNet.Exporters;
 using BenchmarkDotNet.Exporters.Csv;
+using BenchmarkDotNet.Exporters.IntegratedExporter;
 using BenchmarkDotNet.Filters;
 using BenchmarkDotNet.Jobs;
 using BenchmarkDotNet.Loggers;
@@ -40,6 +41,10 @@ public IEnumerable<IExporter> GetExporters()
             yield return HtmlExporter.Default;
         }
 
+        public IEnumerable<IntegratedExporterData> GetIntegratedExporters() => Array.Empty<IntegratedExporterData>();
+
+        public IIntegratedExporter GetIntegratedExporter() => null;
+
         public IEnumerable<ILogger> GetLoggers()
         {
             if (LinqPadLogger.IsAvailable)
@@ -77,7 +82,7 @@ public IEnumerable<IValidator> GetValidators()
         public IOrderer Orderer => null;
         public ICategoryDiscoverer? CategoryDiscoverer => null;
 
-        public ConfigUnionRule UnionRule => ConfigUnionRule.Union;
+        public ConfigUnionRule UnionRule { get; set; } = ConfigUnionRule.Union;
 
         public CultureInfo CultureInfo => null;
 
@@ -113,5 +118,7 @@ public string ArtifactsPath
         public IEnumerable<EventProcessor> GetEventProcessors() => Array.Empty<EventProcessor>();
 
         public IEnumerable<IColumnHidingRule> GetColumnHidingRules() => Array.Empty<IColumnHidingRule>();
+
+
     }
 }
\ No newline at end of file
diff --git a/src/BenchmarkDotNet/Configs/IConfig.cs b/src/BenchmarkDotNet/Configs/IConfig.cs
index b311c235f5..94965960b9 100644
--- a/src/BenchmarkDotNet/Configs/IConfig.cs
+++ b/src/BenchmarkDotNet/Configs/IConfig.cs
@@ -6,6 +6,7 @@
 using BenchmarkDotNet.Diagnosers;
 using BenchmarkDotNet.EventProcessors;
 using BenchmarkDotNet.Exporters;
+using BenchmarkDotNet.Exporters.IntegratedExporter;
 using BenchmarkDotNet.Filters;
 using BenchmarkDotNet.Jobs;
 using BenchmarkDotNet.Loggers;
@@ -20,6 +21,7 @@ public interface IConfig
     {
         IEnumerable<IColumnProvider> GetColumnProviders();
         IEnumerable<IExporter> GetExporters();
+        IEnumerable<IntegratedExporterData> GetIntegratedExporters();
         IEnumerable<ILogger> GetLoggers();
         IEnumerable<IDiagnoser> GetDiagnosers();
         IEnumerable<IAnalyser> GetAnalysers();
diff --git a/src/BenchmarkDotNet/Configs/ImmutableConfig.cs b/src/BenchmarkDotNet/Configs/ImmutableConfig.cs
index b6e03126fd..73bce58ff0 100644
--- a/src/BenchmarkDotNet/Configs/ImmutableConfig.cs
+++ b/src/BenchmarkDotNet/Configs/ImmutableConfig.cs
@@ -8,6 +8,7 @@
 using BenchmarkDotNet.Diagnosers;
 using BenchmarkDotNet.EventProcessors;
 using BenchmarkDotNet.Exporters;
+using BenchmarkDotNet.Exporters.IntegratedExporter;
 using BenchmarkDotNet.Filters;
 using BenchmarkDotNet.Jobs;
 using BenchmarkDotNet.Loggers;
@@ -24,6 +25,7 @@ public sealed class ImmutableConfig : IConfig
         // if something is an array here instead of hashset it means it must have a guaranteed order of elements
         private readonly ImmutableArray<IColumnProvider> columnProviders;
         private readonly ImmutableArray<IExporter> exporters;
+        private readonly ImmutableArray<IntegratedExporterData> integratedExporters;
         private readonly ImmutableHashSet<ILogger> loggers;
         private readonly ImmutableHashSet<IDiagnoser> diagnosers;
         private readonly ImmutableHashSet<IAnalyser> analysers;
@@ -41,6 +43,7 @@ internal ImmutableConfig(
             ImmutableHashSet<HardwareCounter> uniqueHardwareCounters,
             ImmutableHashSet<IDiagnoser> uniqueDiagnosers,
             ImmutableArray<IExporter> uniqueExporters,
+            ImmutableArray<IntegratedExporterData> uniqueIntegratedExporters,
             ImmutableHashSet<IAnalyser> uniqueAnalyzers,
             ImmutableHashSet<IValidator> uniqueValidators,
             ImmutableHashSet<IFilter> uniqueFilters,
@@ -63,6 +66,7 @@ internal ImmutableConfig(
             hardwareCounters = uniqueHardwareCounters;
             diagnosers = uniqueDiagnosers;
             exporters = uniqueExporters;
+            integratedExporters = uniqueIntegratedExporters;
             analysers = uniqueAnalyzers;
             validators = uniqueValidators;
             filters = uniqueFilters;
@@ -92,6 +96,7 @@ internal ImmutableConfig(
 
         public IEnumerable<IColumnProvider> GetColumnProviders() => columnProviders;
         public IEnumerable<IExporter> GetExporters() => exporters;
+        public IEnumerable<IntegratedExporterData> GetIntegratedExporters() => integratedExporters;
         public IEnumerable<ILogger> GetLoggers() => loggers;
         public IEnumerable<IDiagnoser> GetDiagnosers() => diagnosers;
         public IEnumerable<IAnalyser> GetAnalysers() => analysers;
@@ -105,6 +110,7 @@ internal ImmutableConfig(
 
         public ILogger GetCompositeLogger() => new CompositeLogger(loggers);
         public IExporter GetCompositeExporter() => new CompositeExporter(exporters);
+        public IExporter GetCompositeIntegratedExporter() => new CompositeIntegratedExporter(integratedExporters);
         public IValidator GetCompositeValidator() => new CompositeValidator(validators);
         public IAnalyser GetCompositeAnalyser() => new CompositeAnalyser(analysers);
         public IDiagnoser GetCompositeDiagnoser() => new CompositeDiagnoser(diagnosers);
diff --git a/src/BenchmarkDotNet/Configs/ImmutableConfigBuilder.cs b/src/BenchmarkDotNet/Configs/ImmutableConfigBuilder.cs
index d7c0b5eb0f..0e0022cfe3 100644
--- a/src/BenchmarkDotNet/Configs/ImmutableConfigBuilder.cs
+++ b/src/BenchmarkDotNet/Configs/ImmutableConfigBuilder.cs
@@ -1,9 +1,11 @@
 using System.Collections.Generic;
 using System.Collections.Immutable;
 using System.Linq;
+using System.Reflection;
 using BenchmarkDotNet.Analysers;
 using BenchmarkDotNet.Diagnosers;
 using BenchmarkDotNet.Exporters;
+using BenchmarkDotNet.Exporters.IntegratedExporter;
 using BenchmarkDotNet.Jobs;
 using BenchmarkDotNet.Order;
 using BenchmarkDotNet.Reports;
@@ -43,7 +45,28 @@ public static ImmutableConfig Create(IConfig source)
 
             var uniqueHardwareCounters = source.GetHardwareCounters().Where(counter => counter != HardwareCounter.NotSet).ToImmutableHashSet();
             var uniqueDiagnosers = GetDiagnosers(source.GetDiagnosers(), uniqueHardwareCounters);
-            var uniqueExporters = GetExporters(source.GetExporters(), uniqueDiagnosers, configAnalyse);
+
+            var integratedExporters = source?.GetIntegratedExporters();
+            IEnumerable<IExporter>? distinctExporters = null;
+
+            if (integratedExporters?.Any() == true)
+            {
+                distinctExporters = source.GetExporters()
+                    .Where(e =>
+                        !integratedExporters.Any(ie =>
+                            ie.Exporter.GetType() == e.GetType() ||
+                            ie.WithExporter.GetType() == e.GetType() ||
+                            ie.Dependencies?.Any(d => d.GetType() == e.GetType()) == true))
+                    .ToList();
+            }
+            else
+            {
+                distinctExporters = source.GetExporters();
+            }
+
+            var allUniqueExporters = GetExporters(distinctExporters, uniqueDiagnosers, configAnalyse);
+
+            // Check for integrated exporters
             var uniqueAnalyzers = GetAnalysers(source.GetAnalysers(), uniqueDiagnosers);
 
             var uniqueValidators = GetValidators(source.GetValidators(), MandatoryValidators, source.Options);
@@ -60,7 +83,8 @@ public static ImmutableConfig Create(IConfig source)
                 uniqueLoggers,
                 uniqueHardwareCounters,
                 uniqueDiagnosers,
-                uniqueExporters,
+                allUniqueExporters,
+                integratedExporters?.ToImmutableArray() ?? new ImmutableArray<IntegratedExporterData>(),
                 uniqueAnalyzers,
                 uniqueValidators,
                 uniqueFilters,
diff --git a/src/BenchmarkDotNet/Configs/ManualConfig.cs b/src/BenchmarkDotNet/Configs/ManualConfig.cs
index 5ea1be24e9..5110dde0cb 100644
--- a/src/BenchmarkDotNet/Configs/ManualConfig.cs
+++ b/src/BenchmarkDotNet/Configs/ManualConfig.cs
@@ -3,11 +3,13 @@
 using System.ComponentModel;
 using System.Globalization;
 using System.Linq;
+using System.Reflection.Metadata;
 using BenchmarkDotNet.Analysers;
 using BenchmarkDotNet.Columns;
 using BenchmarkDotNet.Diagnosers;
 using BenchmarkDotNet.EventProcessors;
 using BenchmarkDotNet.Exporters;
+using BenchmarkDotNet.Exporters.IntegratedExporter;
 using BenchmarkDotNet.Extensions;
 using BenchmarkDotNet.Filters;
 using BenchmarkDotNet.Jobs;
@@ -23,9 +25,7 @@ namespace BenchmarkDotNet.Configs
     public class ManualConfig : IConfig
     {
         private readonly static Conclusion[] emptyConclusion = Array.Empty<Conclusion>();
-
         private readonly List<IColumnProvider> columnProviders = new List<IColumnProvider>();
-        private readonly List<IExporter> exporters = new List<IExporter>();
         private readonly List<ILogger> loggers = new List<ILogger>();
         private readonly List<IDiagnoser> diagnosers = new List<IDiagnoser>();
         private readonly List<IAnalyser> analysers = new List<IAnalyser>();
@@ -37,8 +37,15 @@ public class ManualConfig : IConfig
         private readonly List<EventProcessor> eventProcessors = new List<EventProcessor>();
         private readonly List<IColumnHidingRule> columnHidingRules = new List<IColumnHidingRule>();
 
+        private List<IExporter> exporters = new List<IExporter>();
+        private List<IntegratedExporterData> integratedExporters = new List<IntegratedExporterData>();
+
+        private IntegratedExportType integratedExporterType;
+        public IntegratedExportType IntegratedExportType => integratedExporterType;
+
         public IEnumerable<IColumnProvider> GetColumnProviders() => columnProviders;
         public IEnumerable<IExporter> GetExporters() => exporters;
+        public IEnumerable<IntegratedExporterData> GetIntegratedExporters() => integratedExporters;
         public IEnumerable<ILogger> GetLoggers() => loggers;
         public IEnumerable<IDiagnoser> GetDiagnosers() => diagnosers;
         public IEnumerable<IAnalyser> GetAnalysers() => analysers;
@@ -139,6 +146,19 @@ public ManualConfig AddExporter(params IExporter[] newExporters)
             return this;
         }
 
+        public ManualConfig AddIntegratedExporter(List<IExporter>? dependencies, IExporter withExporter, IExporter exporter)
+        {
+            integratedExporters.Add(new IntegratedExporterData() { Exporter = exporter, WithExporter = withExporter, Dependencies = dependencies });
+            return this;
+        }
+
+        public ManualConfig SetIntegratedExporterType(IntegratedExportType type)
+        {
+            integratedExporterType = type;
+            return this;
+        }
+
+
         [EditorBrowsable(EditorBrowsableState.Never)]
         [Obsolete("This method will soon be removed, please start using .AddLogger() instead.")]
         public void Add(params ILogger[] newLoggers) => AddLogger(newLoggers);
@@ -256,6 +276,7 @@ public void Add(IConfig config)
         {
             columnProviders.AddRange(config.GetColumnProviders());
             exporters.AddRange(config.GetExporters());
+            integratedExporters.AddRange(config.GetIntegratedExporters());
             loggers.AddRange(config.GetLoggers());
             diagnosers.AddRange(config.GetDiagnosers());
             analysers.AddRange(config.GetAnalysers());
@@ -319,6 +340,8 @@ public static ManualConfig Union(IConfig globalConfig, IConfig localConfig)
             return manualConfig;
         }
 
+
+
         internal void RemoveAllJobs() => jobs.Clear();
 
         internal void RemoveAllDiagnosers() => diagnosers.Clear();
@@ -327,5 +350,6 @@ private static TimeSpan GetBuildTimeout(TimeSpan current, TimeSpan other)
             => current == DefaultConfig.Instance.BuildTimeout
                 ? other
                 : TimeSpan.FromMilliseconds(Math.Max(current.TotalMilliseconds, other.TotalMilliseconds));
+
     }
 }
diff --git a/src/BenchmarkDotNet/Exporters/CompositeExporter.cs b/src/BenchmarkDotNet/Exporters/CompositeExporter.cs
index 95d3bde9d3..f7da35e021 100644
--- a/src/BenchmarkDotNet/Exporters/CompositeExporter.cs
+++ b/src/BenchmarkDotNet/Exporters/CompositeExporter.cs
@@ -35,7 +35,8 @@ public void ExportToLog(Summary summary, ILogger logger)
         }
 
         public IEnumerable<string> ExportToFiles(Summary summary, ILogger consoleLogger)
-            => exporters.SelectMany(exporter =>
+        {
+            return exporters.SelectMany(exporter =>
             {
                 var files = new List<string>();
                 try
@@ -48,5 +49,6 @@ public IEnumerable<string> ExportToFiles(Summary summary, ILogger consoleLogger)
                 }
                 return files;
             });
+        }
     }
 }
\ No newline at end of file
diff --git a/src/BenchmarkDotNet/Exporters/ExporterBase.cs b/src/BenchmarkDotNet/Exporters/ExporterBase.cs
index 17a8d432a6..527798b2ae 100644
--- a/src/BenchmarkDotNet/Exporters/ExporterBase.cs
+++ b/src/BenchmarkDotNet/Exporters/ExporterBase.cs
@@ -54,7 +54,7 @@ internal string GetArtifactFullName(Summary summary)
             return $"{Path.Combine(summary.ResultsDirectoryPath, fileName)}-{FileCaption}{FileNameSuffix}.{FileExtension}";
         }
 
-        private static string GetFileName(Summary summary)
+        protected static string GetFileName(Summary summary)
         {
             // we can't use simple name here, because user might be running benchmarks for a library,  which defines few types with the same name
             // and reports the results per type, so every summary is going to contain just single benchmark
diff --git a/src/BenchmarkDotNet/Exporters/HtmlExporter.cs b/src/BenchmarkDotNet/Exporters/HtmlExporter.cs
index 8fe3068e14..d240c8964e 100644
--- a/src/BenchmarkDotNet/Exporters/HtmlExporter.cs
+++ b/src/BenchmarkDotNet/Exporters/HtmlExporter.cs
@@ -1,10 +1,13 @@
-using BenchmarkDotNet.Extensions;
+using BenchmarkDotNet.Exporters.IntegratedExporter;
+using BenchmarkDotNet.Extensions;
 using BenchmarkDotNet.Loggers;
 using BenchmarkDotNet.Reports;
+using System;
+using System.Collections.Generic;
 
 namespace BenchmarkDotNet.Exporters
 {
-    public class HtmlExporter : ExporterBase
+    public class HtmlExporter : IntegratedExporterExtension
     {
         private const string CssDefinition = @"
 <style type=""text/css"">
@@ -23,7 +26,7 @@ public override void ExportToLog(Summary summary, ILogger logger)
             PrintAll(summary, new HtmlLoggerWrapper(logger));
         }
 
-        private static void PrintAll(Summary summary, ILogger logger)
+        private static void PrintAll(Summary summary, ILogger logger, List<string>? moreData = null)
         {
             logger.WriteLine("<!DOCTYPE html>");
             logger.WriteLine("<html lang='en'>");
@@ -46,6 +49,14 @@ private static void PrintAll(Summary summary, ILogger logger)
 
             PrintTable(summary.Table, logger);
 
+            if (moreData != null)
+            {
+                foreach (var item in moreData)
+                {
+                    logger.WriteLine($"<img src='{item}'/>");
+                }
+            }
+
             logger.WriteLine("</body>");
             logger.WriteLine("</html>");
         }
@@ -96,6 +107,11 @@ private static void PrintLine(SummaryTable table, string[] line, ILogger logger,
             logger.WriteLine();
         }
 
+        public override void IntegratedExportToLog(Summary summary, ILogger logger, object moreData)
+        {
+            PrintAll(summary, logger, moreData as List<string>);
+        }
+
         private class HtmlLoggerWrapper : ILogger
         {
             private readonly ILogger internalLogger;
diff --git a/src/BenchmarkDotNet/Exporters/IntegratedExporter/CompositeIntegratedExporter.cs b/src/BenchmarkDotNet/Exporters/IntegratedExporter/CompositeIntegratedExporter.cs
new file mode 100644
index 0000000000..c43d40afb4
--- /dev/null
+++ b/src/BenchmarkDotNet/Exporters/IntegratedExporter/CompositeIntegratedExporter.cs
@@ -0,0 +1,80 @@
+using BenchmarkDotNet.Extensions;
+using BenchmarkDotNet.Loggers;
+using BenchmarkDotNet.Reports;
+using System;
+using System.Collections.Generic;
+using System.Collections.Immutable;
+using System.Linq;
+using System.Text;
+
+namespace BenchmarkDotNet.Exporters.IntegratedExporter
+{
+    internal class CompositeIntegratedExporter : IExporter
+    {
+        private readonly ImmutableArray<IntegratedExporterData> exporters;
+
+        public CompositeIntegratedExporter(ImmutableArray<IntegratedExporterData> integratedExporters) => this.exporters = integratedExporters;
+
+        public string Name => nameof(CompositeExporter);
+
+        public void ExportToLog(Summary summary, ILogger logger)
+        {
+            if (summary.GetColumns().IsNullOrEmpty())
+                logger.WriteLineHint("You haven't configured any columns, your results will be empty");
+
+            foreach (var exporter in exporters)
+            {
+                try
+                {
+
+                    foreach (var dependencyExporter in exporter?.Dependencies ?? new List<IExporter>())
+                    {
+                        dependencyExporter.ExportToLog(summary, logger);
+                    }
+                    exporter.WithExporter.ExportToLog(summary, logger);
+                    exporter.Exporter.ExportToLog(summary, logger);
+                }
+                catch (Exception e)
+                {
+                    logger.WriteLineError(e.ToString());
+                }
+            }
+        }
+
+        public IEnumerable<string> ExportToFiles(Summary summary, ILogger consoleLogger)
+        {
+            return exporters.SelectMany(exporter =>
+            {
+                var files = new List<string>();
+                try
+                {
+                    var dependencyFiles = (exporter?.Dependencies ?? new List<IExporter>()).SelectMany(dependencyExporter => dependencyExporter.ExportToFiles(summary, consoleLogger));
+                    files.AddRange(dependencyFiles);
+                    foreach (var file in exporter.WithExporter.ExportToFiles(summary, consoleLogger))
+                    {
+                        files.Add(file);
+                    }
+                    if (exporter.Exporter != null && exporter.Exporter is IntegratedExporterExtension exporterBase)
+                    {
+                        object? payload = null;
+                        switch (exporter.ExporterType)
+                        {
+                            case IntegratedExportType.HtmlExporterWithRPlotExporter:
+                                if (exporter.WithExporter is RPlotExporter rPlotExporter)
+                                {
+                                    payload = rPlotExporter.GetExpectedPngPaths(summary, consoleLogger);
+                                }
+                                break;
+                        }
+                        files.AddRange(exporterBase.IntegratedExportToFiles(summary, consoleLogger, payload));
+                    }
+                }
+                catch (Exception e)
+                {
+                    consoleLogger.WriteLineError(e.ToString());
+                }
+                return files;
+            });
+        }
+    }
+}
\ No newline at end of file
diff --git a/src/BenchmarkDotNet/Exporters/IntegratedExporter/IIntegratedExporter.cs b/src/BenchmarkDotNet/Exporters/IntegratedExporter/IIntegratedExporter.cs
new file mode 100644
index 0000000000..3038b20ed2
--- /dev/null
+++ b/src/BenchmarkDotNet/Exporters/IntegratedExporter/IIntegratedExporter.cs
@@ -0,0 +1,17 @@
+using BenchmarkDotNet.Loggers;
+using BenchmarkDotNet.Reports;
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using System.Text;
+
+namespace BenchmarkDotNet.Exporters.IntegratedExporter
+{
+    public interface IIntegratedExporter
+    {
+        string Name { get; }
+        void ExportToLog(Action callback);
+        IEnumerable<string> ExportToFiles(Func<IEnumerable<string>> callback);
+        IntegratedExportType GetIntegratedExportType();
+    }
+}
diff --git a/src/BenchmarkDotNet/Exporters/IntegratedExporter/IntegratedExportType.cs b/src/BenchmarkDotNet/Exporters/IntegratedExporter/IntegratedExportType.cs
new file mode 100644
index 0000000000..d191ef56f0
--- /dev/null
+++ b/src/BenchmarkDotNet/Exporters/IntegratedExporter/IntegratedExportType.cs
@@ -0,0 +1,11 @@
+using System;
+using System.Collections.Generic;
+using System.Text;
+
+namespace BenchmarkDotNet.Exporters.IntegratedExporter
+{
+    public enum IntegratedExportType
+    {
+        HtmlExporterWithRPlotExporter
+    }
+}
diff --git a/src/BenchmarkDotNet/Exporters/IntegratedExporter/IntegratedExporter.cs b/src/BenchmarkDotNet/Exporters/IntegratedExporter/IntegratedExporter.cs
new file mode 100644
index 0000000000..3e003697de
--- /dev/null
+++ b/src/BenchmarkDotNet/Exporters/IntegratedExporter/IntegratedExporter.cs
@@ -0,0 +1,34 @@
+using BenchmarkDotNet.Loggers;
+using BenchmarkDotNet.Reports;
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Text;
+
+namespace BenchmarkDotNet.Exporters.IntegratedExporter
+{
+    public class IntegratedExporter : IIntegratedExporter
+    {
+        private readonly IntegratedExportType integratedExporterTypes;
+        public IntegratedExporter(IntegratedExportType integratedExporterTypes)
+        {
+            this.integratedExporterTypes = integratedExporterTypes;
+        }
+        public string Name => nameof(IntegratedExporter);
+
+        public IEnumerable<string> ExportToFiles(Func<IEnumerable<string>> callback)
+        {
+            var result = callback();
+            return result;
+        }
+
+        public void ExportToLog(Action callback)
+        {
+            callback();
+        }
+
+        public IntegratedExportType GetIntegratedExportType() => integratedExporterTypes;
+    }
+
+
+}
diff --git a/src/BenchmarkDotNet/Exporters/IntegratedExporter/IntegratedExporterData.cs b/src/BenchmarkDotNet/Exporters/IntegratedExporter/IntegratedExporterData.cs
new file mode 100644
index 0000000000..29d84c3f0f
--- /dev/null
+++ b/src/BenchmarkDotNet/Exporters/IntegratedExporter/IntegratedExporterData.cs
@@ -0,0 +1,14 @@
+using System;
+using System.Collections.Generic;
+using System.Text;
+
+namespace BenchmarkDotNet.Exporters.IntegratedExporter
+{
+    public class IntegratedExporterData
+    {
+        public IExporter Exporter { get; set; }
+        public IExporter WithExporter { get; set; }
+        public List<IExporter>? Dependencies { get; set; }
+        public IntegratedExportType ExporterType { get; set; }
+    }
+}
diff --git a/src/BenchmarkDotNet/Exporters/IntegratedExporter/IntegratedExporterExtension.cs b/src/BenchmarkDotNet/Exporters/IntegratedExporter/IntegratedExporterExtension.cs
new file mode 100644
index 0000000000..416f7eb96e
--- /dev/null
+++ b/src/BenchmarkDotNet/Exporters/IntegratedExporter/IntegratedExporterExtension.cs
@@ -0,0 +1,45 @@
+using BenchmarkDotNet.Loggers;
+using BenchmarkDotNet.Reports;
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Text;
+
+namespace BenchmarkDotNet.Exporters.IntegratedExporter
+{
+    public abstract class IntegratedExporterExtension : ExporterBase
+    {
+        public abstract void IntegratedExportToLog(Summary summary, ILogger logger, object moreData);
+
+        public IEnumerable<string> IntegratedExportToFiles(Summary summary, ILogger consoleLogger, object moreData = null)
+        {
+            string fileName = GetFileName(summary);
+            string filePath = GetArtifactFullName(summary);
+            if (File.Exists(filePath))
+            {
+                try
+                {
+                    File.Delete(filePath);
+                }
+                catch (IOException)
+                {
+                    string uniqueString = DateTime.Now.ToString("yyyyMMdd-HHmmss");
+                    string alternativeFilePath = $"{Path.Combine(summary.ResultsDirectoryPath, fileName)}-{FileCaption}{FileNameSuffix}-{uniqueString}.{FileExtension}";
+                    consoleLogger.WriteLineError($"Could not overwrite file {filePath}. Exporting to {alternativeFilePath}");
+                    filePath = alternativeFilePath;
+                }
+            }
+
+            using (var stream = new StreamWriter(filePath, append: false))
+            {
+                using (var streamLogger = new StreamLogger(stream))
+                {
+                    IntegratedExportToLog(summary, streamLogger, moreData);
+                }
+            }
+
+            return new[] { filePath };
+        }
+
+    }
+}
diff --git a/src/BenchmarkDotNet/Exporters/RPlotExporter.cs b/src/BenchmarkDotNet/Exporters/RPlotExporter.cs
index c90338f490..2f076d0527 100644
--- a/src/BenchmarkDotNet/Exporters/RPlotExporter.cs
+++ b/src/BenchmarkDotNet/Exporters/RPlotExporter.cs
@@ -2,6 +2,8 @@
 using System.Collections.Generic;
 using System.Diagnostics;
 using System.IO;
+using System.Linq;
+using System.Threading;
 using BenchmarkDotNet.Detectors;
 using BenchmarkDotNet.Exporters.Csv;
 using BenchmarkDotNet.Helpers;
@@ -19,7 +21,6 @@ public class RPlotExporter : IExporter, IExporterDependencies
 
         private const string ImageExtension = ".png";
         private static readonly object BuildScriptLock = new object();
-
         public IEnumerable<IExporter> Dependencies
         {
             // R Plots depends on having the full measurements available
@@ -57,7 +58,7 @@ public IEnumerable<string> ExportToFiles(Summary summary, ILogger consoleLogger)
                 WorkingDirectory = summary.ResultsDirectoryPath,
                 Arguments = $"\"{scriptFullPath}\" \"{csvFullPath}\""
             };
-            using (var process = new Process {StartInfo = start})
+            using (var process = new Process { StartInfo = start })
             using (AsyncProcessOutputReader reader = new AsyncProcessOutputReader(process))
             {
                 // When large R scripts are generated then ran, ReadToEnd()
@@ -147,5 +148,123 @@ private static bool TryFindRScript(ILogger consoleLogger, out string? rscriptPat
             }
             return null;
         }
+
+        public List<string> GetExpectedPngPaths(Summary summary, ILogger consoleLogger)
+        {
+            const string scriptFileName = "get-png-paths-script.R";
+            var pngPaths = new List<string>();
+
+            // Create R script content
+            string script = @"
+if (!require(dplyr)) install.packages('dplyr')
+library(dplyr)
+
+ends_with <- function(vars, match, ignore.case = TRUE) {
+  if (ignore.case) match <- tolower(match)
+  n <- nchar(match)
+  if (ignore.case) vars <- tolower(vars)
+  length <- nchar(vars)
+  substr(vars, pmax(1, length - n + 1), length) == match
+}
+
+list_benchmark_png_paths <- function(measurement_files) {
+  paths <- c()
+  for (file in measurement_files) {
+    title <- gsub('-measurements.csv', '', basename(file))
+    paths <- c(paths,
+              gsub('-measurements.csv', '-boxplot.png', file),
+              gsub('-measurements.csv', '-barplot.png', file))
+    
+    measurements <- read.csv(file, sep = ',')
+    result <- measurements %>% filter(Measurement_IterationStage == 'Result')
+    
+    for (target in unique(result$Target_Method)) {
+      paths <- c(paths,
+                gsub('-measurements.csv', paste0('-', target, '-density.png'), file),
+                gsub('-measurements.csv', paste0('-', target, '-facetDensity.png'), file),
+                gsub('-measurements.csv', paste0('-', target, '-facetTimeline.png'), file),
+                gsub('-measurements.csv', paste0('-', target, '-facetTimelineSmooth.png'), file),
+                gsub('-measurements.csv', paste0('-', target, '-cummean.png'), file))
+      
+      df <- result %>% filter(Target_Method == target)
+      
+      for (params in unique(df$Params)) {
+        if (!is.na(params)) {
+          prefix <- paste0('-', target, '-', params)
+          paths <- c(paths,
+                    gsub('-measurements.csv', paste0(prefix, '-density.png'), file),
+                    gsub('-measurements.csv', paste0(prefix, '-facetDensity.png'), file))
+        }
+      }
+      
+      for (job in unique(df$Job_Id)) {
+        if (!is.na(job)) {
+          paths <- c(paths,
+                    gsub('-measurements.csv', paste0('-', target, '-', job, '-timeline.png'), file),
+                    gsub('-measurements.csv', paste0('-', target, '-', job, '-timelineSmooth.png'), file),
+                    gsub('-measurements.csv', paste0('-', target, '-', job, '-cummean.png'), file),
+                    gsub('-measurements.csv', paste0('-', target, '-', job, '-density.png'), file))
+        }
+      }
+    }
+  }
+  return(unique(paths))
+}
+
+files <- list.files(pattern = '*-measurements.csv')
+if (length(files) > 0) {
+  png_paths <- list_benchmark_png_paths(files)
+  cat(png_paths, sep='\n')
+}";
+
+            // Write script file
+            string scriptFullPath = Path.Combine(summary.ResultsDirectoryPath, scriptFileName);
+            File.WriteAllText(scriptFullPath, script);
+
+            // Find RScript executable
+            if (!TryFindRScript(consoleLogger, out string rscriptPath))
+            {
+                throw new InvalidOperationException("RScript executable not found");
+            }
+
+            // Prepare process
+            var startInfo = new ProcessStartInfo
+            {
+                UseShellExecute = false,
+                RedirectStandardOutput = true,
+                RedirectStandardError = true,
+                CreateNoWindow = true,
+                FileName = rscriptPath,
+                WorkingDirectory = summary.ResultsDirectoryPath,
+                Arguments = $"\"{scriptFullPath}\""
+            };
+
+            // Execute and collect output
+            using (var process = new Process { StartInfo = startInfo })
+            {
+                var output = new List<string>();
+                var outputDone = new ManualResetEventSlim();
+
+                process.OutputDataReceived += (sender, e) =>
+                {
+                    if (e.Data == null)
+                        outputDone.Set();
+                    else if (e.Data.EndsWith(".png", StringComparison.OrdinalIgnoreCase))
+                        output.Add(e.Data.Trim());
+                };
+
+                process.Start();
+                process.BeginOutputReadLine();
+                process.WaitForExit();
+                outputDone.Wait();
+
+                // Convert relative paths to full paths
+                pngPaths.AddRange(output.Select(p => Path.Combine(summary.ResultsDirectoryPath, p)));
+
+                outputDone.Dispose();
+            }
+
+            return pngPaths;
+        }
     }
 }
diff --git a/src/BenchmarkDotNet/Running/BenchmarkConverter.cs b/src/BenchmarkDotNet/Running/BenchmarkConverter.cs
index 69837feec8..22221d9828 100644
--- a/src/BenchmarkDotNet/Running/BenchmarkConverter.cs
+++ b/src/BenchmarkDotNet/Running/BenchmarkConverter.cs
@@ -7,8 +7,11 @@
 using BenchmarkDotNet.Attributes;
 using BenchmarkDotNet.Code;
 using BenchmarkDotNet.Configs;
+using BenchmarkDotNet.Exporters;
+using BenchmarkDotNet.Exporters.IntegratedExporter;
 using BenchmarkDotNet.Extensions;
 using BenchmarkDotNet.Filters;
+using BenchmarkDotNet.Order;
 using BenchmarkDotNet.Parameters;
 using BenchmarkDotNet.Reports;
 
@@ -16,7 +19,7 @@ namespace BenchmarkDotNet.Running
 {
     public static partial class BenchmarkConverter
     {
-        private const BindingFlags AllMethodsFlags =  BindingFlags.Static | BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic;
+        private const BindingFlags AllMethodsFlags = BindingFlags.Static | BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic;
 
         public static BenchmarkRunInfo TypeToBenchmarks(Type type, IConfig? config = null)
         {
@@ -87,15 +90,46 @@ private static ImmutableConfig GetFullTypeConfig(Type type, IConfig? config)
         {
             config = config ?? DefaultConfig.Instance;
 
+
             var typeAttributes = type.GetCustomAttributes(true).OfType<IConfigSource>();
             var assemblyAttributes = type.Assembly.GetCustomAttributes().OfType<IConfigSource>();
 
             foreach (var configFromAttribute in assemblyAttributes.Concat(typeAttributes))
-                config = ManualConfig.Union(config, configFromAttribute.Config);
+            {
+                if (configFromAttribute.GetType().Name == "IntegratedExporterAttribute" && configFromAttribute.Config is ManualConfig manualConfig)
+                {
+                    IntegratedExportType integratedExportType = manualConfig.IntegratedExportType;
+                    bool success = TryGetIntegratedExportersByType(integratedExportType, out List<IExporter>? dependencies, out IExporter exporter, out IExporter withExporter);
+                    if (!success || withExporter == null || exporter == null) continue;
+                    config = ManualConfig.Union(config, ManualConfig.CreateEmpty().AddIntegratedExporter(dependencies, withExporter, exporter));
+                }
+                else
+                {
+                    config = ManualConfig.Union(config, configFromAttribute.Config);
+                }
+            }
+
 
             return ImmutableConfigBuilder.Create(config);
         }
 
+        private static bool TryGetIntegratedExportersByType(IntegratedExportType type, out List<IExporter>? dependencies, out IExporter exporter, out IExporter withExporter)
+        {
+            switch (type)
+            {
+                case IntegratedExportType.HtmlExporterWithRPlotExporter:
+                    exporter = HtmlExporter.Default;
+                    withExporter = RPlotExporter.Default;
+                    dependencies = (withExporter is IExporterDependencies exporterDependencies) ? exporterDependencies.Dependencies.ToList() : null;
+                    return true;
+                default:
+                    exporter = null;
+                    withExporter = null;
+                    dependencies = null;
+                    return false;
+            }
+        }
+
         private static ImmutableConfig GetFullMethodConfig(MethodInfo method, ImmutableConfig typeConfig)
         {
             var methodAttributes = method.GetCustomAttributes(true).OfType<IConfigSource>();
diff --git a/src/BenchmarkDotNet/Running/BenchmarkRunnerClean.cs b/src/BenchmarkDotNet/Running/BenchmarkRunnerClean.cs
index 6d9d48c3cc..54e0f1d1e7 100644
--- a/src/BenchmarkDotNet/Running/BenchmarkRunnerClean.cs
+++ b/src/BenchmarkDotNet/Running/BenchmarkRunnerClean.cs
@@ -14,6 +14,7 @@
 using BenchmarkDotNet.Environments;
 using BenchmarkDotNet.EventProcessors;
 using BenchmarkDotNet.Exporters;
+using BenchmarkDotNet.Exporters.IntegratedExporter;
 using BenchmarkDotNet.Extensions;
 using BenchmarkDotNet.Helpers;
 using BenchmarkDotNet.Jobs;
@@ -297,6 +298,15 @@ private static void PrintSummary(ILogger logger, ImmutableConfig config, Summary
                 logger.WriteLineInfo($"  {file.GetBaseName(currentDirectory)}");
             }
 
+            if ((config?.GetIntegratedExporters() ?? new List<IntegratedExporterData>()).Any())
+            {
+                foreach (string file in config.GetCompositeIntegratedExporter().ExportToFiles(summary, logger))
+                {
+                    logger.WriteLineInfo($"  {file.GetBaseName(currentDirectory)}");
+                }
+            }
+
+
             logger.WriteLine();
 
             logger.WriteLineHeader("// * Detailed results *");