How to Create Publication-Quality Figures for Your Research Paper

A 2023 PLOS ONE study found that researchers spend a median of 14 hours reformatting each manuscript for journal submission, with figure preparation consistently ranking among the most time-consuming tasks. If you have ever struggled with how to make figures for research paper submissions, you are not alone. Between cryptic DPI requirements, inconsistent font scaling, and the bewildering number of tools available, the process of turning raw results into publication-ready visuals can feel like a research project in itself.

This guide walks you through every step: the technical standards your target venue demands, the tools that can get you there, and the common mistakes that cause desk rejections. Whether you are a first-year PhD student preparing your debut NeurIPS submission or a postdoc polishing a journal revision, by the end you will have a clear, repeatable workflow for creating figures that strengthen rather than undermine your work.

Key Takeaways

• Resolution and format matter: Use vector formats (PDF, EPS, SVG) for diagrams and at least 300 DPI for raster images. Line art requires 600 DPI.
• Font sizing survives scaling: Set axis labels and annotations to at least 8 pt after the figure is scaled to the final column width, and match the document typeface.
• Color accessibility is not optional: Roughly 8% of men have some form of color-vision deficiency. Design every figure to be interpretable in grayscale and with colorblind-safe palettes.
• One figure, one message: The single most effective way to improve a figure is to ruthlessly cut it down to a single, clearly stated takeaway.
• AI tools are reshaping the workflow: Multi-agent pipelines like PaperBanana's Paper Visualizer can now generate and iteratively refine both diagrams and data plots, saving hours of manual formatting.

Why Figure Quality Matters More Than You Think

Ask any journal editor what they notice first when they open a new submission, and the answer is almost always "the figures." Before reading a single paragraph, reviewers form an impression of the paper's rigor based on visual presentation. A pixelated architecture diagram or a bar chart with truncated axes signals carelessness, fairly or not.

This is not speculation. Elsevier's widely cited "8 Reasons I Rejected Your Article" editorial explicitly lists poor-quality figures as a factor that erodes reviewer confidence. When an editor processes dozens of manuscripts per week, marginal papers with sloppy visuals are the easiest to desk-reject.

Figures also serve a unique communicative role. The human visual system processes structured imagery far faster than linear text. A well-designed training curve can convey in three seconds what takes two paragraphs to describe. Conversely, a confusing figure forces the reader to context-switch between the caption, the text, and the visual, breaking the flow of comprehension. In competitive venues like NeurIPS, ICML, and CVPR, where reviewers are volunteers reading papers after their day jobs, that cognitive friction can be the difference between a weak accept and a reject.

The implication is straightforward: investing in publication quality figures is not cosmetic polishing. It is a strategic decision that directly affects how your contribution is perceived and, ultimately, whether it is accepted.

The Technical Requirements You Can't Ignore

Every major publisher and conference provides a style guide. The specifics vary, but three requirements appear almost universally: resolution, font sizing, and color handling.

Resolution and DPI

DPI (dots per inch) determines how sharp a raster image appears in print. The industry standard minimum is 300 DPI for halftone images (photographs, heatmaps, gradient-heavy plots). For line art---architecture diagrams, flowcharts, schematics---most publishers require 600 DPI because aliased edges become visible at lower resolutions.

The cleanest solution is to avoid the DPI question entirely by using vector formats. PDF, EPS, and SVG store shapes as mathematical descriptions rather than pixel grids, so they scale perfectly to any size. If your figure is a diagram, a line plot, or a bar chart, export it as a vector. Reserve raster formats (PNG, TIFF) for photographs, microscopy images, or figures with complex gradient fills that vector renderers handle poorly.

A common mistake in the matplotlib ecosystem is calling plt.show() and then screenshotting the output window, or saving to PNG at the default 100 DPI. Both produce images that look acceptable on screen but fall apart in print. The fix is simple:

plt.savefig('figure1.pdf', bbox_inches='tight', dpi=300)

Even when saving to PDF (a vector format), the dpi parameter still affects the rasterization of certain elements like transparency and embedded images, so setting it explicitly is good practice.

Font Sizing for Readability

Font size in figures is deceptive. You might set axis labels to 12 pt in matplotlib, but if the figure is then scaled from 8 inches wide to a 3.25-inch single-column layout, those labels shrink to roughly 5 pt---below the threshold of comfortable reading.

The rule of thumb across major publishers is that no text element should be smaller than 8 pt after scaling to the final column width. To achieve this, you need to know your target venue's column width upfront:

Set your matplotlib figsize to the actual column width (or the width you plan to use), and then choose font sizes that are readable at that size without any additional scaling. For NeurIPS, a figsize=(5.5, 3.5) with 10 pt labels works well. For IEEE two-column formats, figsize=(3.25, 2.5) with 8--9 pt labels is a safer starting point.

You should also match the document's body font. NeurIPS uses Times; CVPR uses a similar serif stack. If your figure labels are in Helvetica while the body text is in Times New Roman, the visual inconsistency is subtle but noticeable. In matplotlib, you can set this globally:

import matplotlib.pyplot as plt
plt.rcParams.update({
    'font.family': 'serif',
    'font.serif': ['Times New Roman'],
    'font.size': 10,
    'axes.labelsize': 10,
    'xtick.labelsize': 8,
    'ytick.labelsize': 8,
    'legend.fontsize': 8,
    'figure.figsize': (5.5, 3.5),
    'savefig.dpi': 300,
    'savefig.bbox': 'tight',
})

Color Accessibility

Approximately 8% of men and 0.5% of women have some degree of color-vision deficiency, most commonly an inability to distinguish red from green. In a conference room of 200 attendees, that is roughly 8 people who cannot read your red-vs-green ablation comparison.

The fix is twofold. First, use colorblind-safe palettes. The matplotlib defaults have improved significantly since version 3.0, but the safest choices remain perceptually uniform colormaps like viridis, cividis, inferno, and plasma. These are designed to be distinguishable by people with the most common forms of color blindness and to degrade gracefully when printed in grayscale.

Second, never encode information with color alone. Supplement color with marker shapes, line styles (solid, dashed, dotted), or direct annotations. If you remove all color from your figure and it becomes unreadable, you have a design problem.

The seminal reference here is Rougier, Droettboom, and Bourne's "Ten Simple Rules for Better Figures," published in PLOS Computational Biology. Rule 4---"Caution with Colors"---devotes particular attention to this issue and is worth reading in full.

Choosing the Right Tool for Your Figures

The tool landscape for academic figures is broad, and the right choice depends on what kind of figure you are making.

For Data Plots: matplotlib, seaborn, ggplot2

matplotlib remains the dominant plotting library in the Python ecosystem, and for good reason. It offers nearly unlimited customization over every visual element. The downside is verbosity: a publication-quality plot can easily require 40--60 lines of rcParams tweaks and manual adjustments. The default aesthetics, while vastly improved from the pre-3.0 era, still require heavy tuning for most academic venues.

Several community projects exist to bridge this gap. SciencePlots provides ready-made matplotlib stylesheets for major journals and conferences (plt.style.use('science')). tueplots from the University of Tubingen generates venue-specific figure sizes and font configurations. mpl_sizes tackles the font-scaling problem directly. These are valuable time-savers, though they cover only a subset of venues and still require manual fine-tuning.

It is worth noting that a long-standing community request for built-in publication-quality styles in matplotlib (GitHub issue #19028) was ultimately closed as "won't fix," with the maintainers recommending external stylesheet packages instead. This means matplotlib publication quality styling will likely remain a DIY or community-driven effort for the foreseeable future.

seaborn wraps matplotlib with a higher-level API that is particularly strong for statistical visualizations---violin plots, heatmaps, pair plots. It produces attractive defaults with less code but gives you less granular control when you need to deviate from its assumptions.

ggplot2 in the R ecosystem follows a grammar-of-graphics philosophy that many researchers find more intuitive for exploratory analysis. Its theming system makes it straightforward to produce consistent, publication-ready output, though interoperability with LaTeX-heavy workflows can be frictional.

For Diagrams: TikZ, draw.io, Figma

TikZ is the gold standard for diagrams in LaTeX documents. Its output is unmatched: perfectly rendered vector graphics that share the document's fonts and integrate seamlessly into the PDF. The cost is a ferociously steep learning curve. The TikZ/PGF manual exceeds 1,300 pages. Drawing a moderately complex neural network architecture diagram can take an experienced user several hours and a novice an entire day.

draw.io (now diagrams.net) is free, browser-based, and easy to learn. For quick internal diagrams and presentations, it is excellent. For publication figures, however, its export quality is limited---SVG output occasionally has rendering inconsistencies, and the aesthetic ceiling is lower than TikZ or professional design tools.

Figma has gained traction in research groups that value collaboration. Multiple co-authors can edit a figure simultaneously, and its vector output is clean. The main limitation is that it is not natively integrated with LaTeX workflows: you export to SVG or PDF and include the result manually, which creates a disconnect when you need to match document fonts or update figures during revisions.

For AI-Assisted Generation

The landscape for AI-assisted scientific figure creation is evolving rapidly. BioRender has established itself in the life sciences with a template library optimized for biological diagrams. FigureLabs uses AI to convert rough sketches into cleaner illustrations.

For researchers in computer science and machine learning, PaperBanana's Paper Visualizer offers a different approach. Rather than relying on a single model call, it uses a 7-agent pipeline---Retriever, Planner, Stylist, Visualizer, Critic, Vanilla, and Polish---to generate diagrams from methodology text or data plots from raw data. The Critic agent evaluates each generation and drives iterative refinement, producing output that is closer to publication quality without manual intervention. The key differentiator is this multi-round critique loop: instead of generating once and hoping for the best, the system systematically identifies and corrects issues across multiple iterations.

This does not make manual tools obsolete. Complex, highly customized figures will still benefit from hand-tuned matplotlib code or carefully crafted TikZ. But for the 80% of figures that follow standard patterns---architecture diagrams, training curves, comparison bar charts---AI-assisted generation can collapse hours of formatting work into minutes. For a deeper look at how researchers are incorporating AI tools into their illustration workflows, see our guide on AI scientific illustration tips from a PhD researcher.

Step-by-Step: From Raw Data to Publication-Ready Plot

Theory is useful. A concrete workflow is better. Here is a four-step process that works across tools and venues.

Step 1: Define the Message

Before opening any tool, answer one question: "What do I want the reader to understand within five seconds of looking at this figure?"

A single figure should communicate a single message. "Our method converges faster than all baselines" is a message. "Our method converges faster, achieves lower final loss, and is more stable across random seeds" is three messages crammed into one figure---and the reader will likely miss at least one of them.

If you find yourself needing to communicate multiple points, consider splitting the figure into subplots (a, b, c) with a shared caption, or creating separate figures entirely. The cost of an extra figure slot is almost always lower than the cost of a confused reviewer.

Step 2: Choose the Right Chart Type

Matching your data to the right chart type is not just an aesthetic choice; it determines how quickly and accurately readers extract information.

A few strong opinions that are widely shared in the data visualization community: avoid 3D bar charts (they distort perception of bar heights), avoid pie charts when you have more than three categories (angular differences are harder to perceive than length differences), and avoid dual y-axes unless absolutely necessary (they invite misinterpretation of correlation).

Step 3: Style for Your Target Venue

Once you know the chart type, configure your tool for the target venue's requirements. Here is a minimal matplotlib setup for a NeurIPS-style single-column figure:

import matplotlib.pyplot as plt
import numpy as np

# NeurIPS-style configuration
plt.rcParams.update({
    'font.family': 'serif',
    'font.serif': ['Times New Roman'],
    'font.size': 10,
    'axes.linewidth': 0.8,
    'axes.labelsize': 10,
    'xtick.labelsize': 8,
    'ytick.labelsize': 8,
    'legend.fontsize': 8,
    'legend.frameon': False,
    'figure.figsize': (5.5, 3.5),
    'savefig.dpi': 300,
    'savefig.bbox': 'tight',
    'savefig.pad_inches': 0.05,
})

# Example: training loss comparison
epochs = np.arange(1, 101)
loss_ours = 2.0 * np.exp(-0.05 * epochs) + 0.1 + np.random.normal(0, 0.02, 100)
loss_baseline = 2.0 * np.exp(-0.03 * epochs) + 0.3 + np.random.normal(0, 0.02, 100)

fig, ax = plt.subplots()
ax.plot(epochs, loss_ours, label='Ours', color='#1f77b4', linewidth=1.5)
ax.plot(epochs, loss_baseline, label='Baseline', color='#ff7f0e',
        linewidth=1.5, linestyle='--')
ax.set_xlabel('Epoch')
ax.set_ylabel('Validation Loss')
ax.legend()
ax.set_xlim(1, 100)
ax.set_ylim(0, 2.2)

plt.savefig('training_loss.pdf', bbox_inches='tight', dpi=300)

This produces a clean, correctly sized figure that can be included in a LaTeX document with \includegraphics[width=\columnwidth]{training_loss.pdf} without any additional scaling.

Alternatively, if you prefer an AI-assisted approach, you can paste your raw data (CSV, JSON, or a table) into PaperBanana's Paper Visualizer along with a description of the plot you want---"training loss comparison, NeurIPS style, two methods, log scale on y-axis"---and the pipeline will generate a matplotlib-based plot with appropriate styling and iterative refinement.

Step 4: Export Correctly

The final step is easy to get right and catastrophic to get wrong.

For diagrams and line plots, export as PDF or EPS. These vector formats preserve sharpness at any zoom level and produce smaller file sizes than high-resolution rasters.

For photographs and complex raster content (e.g., microscopy images, satellite imagery), use TIFF at 300 DPI or higher. TIFF is lossless, unlike JPEG, which introduces compression artifacts---especially visible around text and sharp edges.

Avoid these common export mistakes:

• Screenshotting plt.show() output (produces ~72 DPI, far below the minimum)
• Saving to JPEG for any figure containing text or line art (lossy compression degrades edges)
• Exporting from Google Slides or PowerPoint at default resolution (typically 96 DPI)

If your workflow involves multiple figures, consider writing a small export script that applies consistent settings. Consistency across all figures in a paper signals attention to detail.

5 Common Mistakes That Get Figures Rejected

Based on reviewer feedback across major ML/AI venues and the published editorial guidance from journals like Nature, PLOS, and IEEE, these are the most frequent figure-related issues.

1. Information Overload

The most common mistake is trying to show everything at once. A single plot with 12 overlapping lines, a legend that occupies a quarter of the figure area, and axis labels that require a magnifying glass does not demonstrate thoroughness. It demonstrates a failure to prioritize.

The fix: move secondary comparisons to the appendix or supplementary material. Keep the main paper figures focused on your central claims.

2. Inconsistent Formatting Across Figures

Figure 1 uses Helvetica at 12 pt with a white background. Figure 3 uses Arial at 10 pt with a light gray background. Figure 5 uses the matplotlib default style entirely. This inconsistency signals that the figures were created at different times with different settings and never harmonized.

The fix: define a shared style configuration (a matplotlib stylesheet, a Figma component library, or a TikZ preamble) and apply it to every figure in the paper.

3. Illegible Labels After Column Scaling

You designed the figure at 10 inches wide. The journal renders it at 3.25 inches. Your 10 pt labels are now 3.25 pt---invisible. This is among the most frequently cited reasons for publisher production queries and revision requests.

The fix: always design at the target column width, not at an arbitrary size. If you must design larger (for comfort), verify the final appearance by printing the figure at its actual column width.

4. Missing or Misleading Error Bars

Reporting mean performance without variance is incomplete at best and misleading at worst. Reviewers at venues like NeurIPS and ICML routinely flag the absence of error bars or confidence intervals. Equally problematic is including error bars without specifying whether they represent standard deviation, standard error, or a confidence interval.

The fix: always include error bars or shaded confidence regions for stochastic results. State explicitly in the caption what the error bars represent and over how many runs or seeds.

5. Using 3D Effects When 2D Suffices

3D bar charts, 3D pie charts, and gratuitous perspective rotations are a holdover from the era of PowerPoint business presentations. In academic figures, 3D effects distort perception: bars at the back of a 3D chart appear shorter than bars at the front, even when they represent the same value.

The fix: use 2D representations unless the third dimension encodes meaningful data (e.g., a 3D scatter plot where x, y, and z all represent measured variables). If your chart is fundamentally two-dimensional, render it that way.

For a more detailed discussion of how PaperBanana's multi-agent system addresses several of these common mistakes through automated critique and refinement, see our article on how PaperBanana revolutionizes academic illustration.

FAQ

What DPI should figures be for journal submission?

The standard minimum is 300 DPI for halftone (photographic) images and 600 DPI for line art (diagrams, charts with sharp edges). Vector formats like PDF and EPS are resolution-independent and are preferred for any figure that does not contain photographic content. When in doubt, check your target venue's author guidelines---Nature, IEEE, and Springer all publish specific resolution requirements.

Can I use PowerPoint for research paper figures?

Technically yes, and many researchers do. PowerPoint is familiar, requires no coding, and supports basic drawing tools. However, it has significant limitations for publication figures: default export resolution is 96 DPI (far below the 300 DPI minimum), text rendering is inconsistent across platforms, and aligning elements precisely is cumbersome. If you use PowerPoint, export at the highest available resolution and verify the output at print size. For anything beyond simple block diagrams, a dedicated tool---matplotlib, TikZ, or even Figma---will produce better results with less frustration.

What image format is best for research paper figures?

It depends on the content:

• PDF or EPS for diagrams, line plots, bar charts, and any figure composed of text, lines, and shapes. These are vector formats that scale perfectly.
• TIFF (lossless) for photographs, microscopy images, and other complex raster content.
• PNG as a fallback raster format when TIFF is not accepted. PNG is lossless, unlike JPEG.
• JPEG only for photographs where file size is a hard constraint. Never use JPEG for figures containing text or sharp edges.
• SVG for web-based publications and supplementary material.

How long should it take to create a figure?

This varies enormously by figure complexity and the creator's experience level. The PLOS ONE reformatting study suggests that figure preparation is a substantial component of the 14 hours researchers spend on manuscript formatting. Anecdotally, a polished matplotlib figure with proper styling takes an experienced user 30--90 minutes; a complex TikZ diagram can take 2--6 hours; a simple diagram in draw.io or Figma might take 15--30 minutes.

AI-assisted tools are compressing these timescales. Multi-agent systems like PaperBanana can generate a styled diagram or data plot in minutes, though you should always review and fine-tune the output. The goal is not to eliminate human judgment but to eliminate the hours of formatting boilerplate that precede it.

Can I use AI-generated figures in my papers?

Yes, with caveats. AI-generated diagrams and data plots are tools for visualization, analogous to using matplotlib or TikZ---the intellectual content (the data, the methodology, the analysis) is yours; the tool merely renders it visually.

That said, policies are evolving. The NeurIPS 2024 paper checklist asks authors to disclose AI-assisted content, including figures. Some journals require a statement in the methods section acknowledging AI tool usage. The key is transparency: disclose the tool, ensure the figure accurately represents your data or methodology, and verify that your target venue's policy permits AI-assisted figure generation. As of early 2026, no major ML/AI venue prohibits AI-generated diagrams or plots, but always check the latest author guidelines before submission.

Conclusion

Creating publication-quality figures is not an innate talent. It is a learnable skill built on a handful of concrete principles: design at the target column width, use vector formats for diagrams, respect the 8 pt minimum font size after scaling, choose colorblind-safe palettes, and limit each figure to a single message. Master these fundamentals and your figures will consistently meet the bar that editors and reviewers expect.

The tooling landscape is richer than ever. matplotlib and its ecosystem of style packages give you full control when you need it. TikZ produces unmatched LaTeX-integrated output for those willing to invest the learning time. And AI-assisted tools like PaperBanana's Paper Visualizer are making it possible to go from raw data or methodology text to a styled, iteratively refined figure in a fraction of the time.

Whatever tool you choose, the principles remain the same. Start with a clear message, style for your target venue, export correctly, and review the output at print size. Your figures are often the first thing reviewers see. Make that first impression count.