LaTeX Code Listings: listings vs minted, inline code, and shell-escape

Use listings if you want code blocks that work without external tools. Use minted if you want better syntax highlighting and you can compile with -shell-escape. This guide covers both packages, inline code, file imports, and the common errors that usually break minted.

Quick answer: listings is simpler and works in more build setups. minted uses Pygments, so it needs -shell-escape, but it gives better highlighting and more control over styles.Related topics: Text formatting | Fonts | Headers & footers | Errors

listings vs minted

If you need…	Use	Why
A code block that compiles without shell-escape	`listings`	It stays inside LaTeX and is easier to use in restricted environments
Better syntax highlighting and more built-in themes	`minted`	It uses Pygments for language-aware highlighting
Inline code in ordinary text	`\lstinline` or `\mintinline`	Both packages support inline code
A build setup that works on locked-down CI or editors	`listings`	`minted` often fails when shell execution is disabled
Publication-style code examples	`minted`	Output is usually cleaner with less manual styling

Quick Start

Minimal `listings` setup

Use this when you want a simple code block and do not want to change your compiler settings.

listings-quickstart.tex

\documentclass{article}
\usepackage{listings}

\begin{document}

\begin{lstlisting}[language=Python]
def hello():
    print("Hello, world!")
\end{lstlisting}

\end{document}

Minimal `minted` setup

Use this when you want syntax highlighting and your editor or build command supports -shell-escape.

minted-quickstart.tex

\documentclass{article}
\usepackage{minted}

\begin{document}

\begin{minted}{python}
def hello():
    print("Hello, world!")
\end{minted}

\end{document}

Compile with:

pdflatex -shell-escape file.tex

The usual `minted` failure

If minted does not compile, the problem is usually one of these:

-shell-escape is missing
Python or Pygments is not available in the build environment
your editor or CI runner blocks external commands

If you cannot change the build setup, use listings instead.

Inline code

For short snippets inside a paragraph:

inline-code.tex

Use \lstinline|--shell-escape| with listings examples.

Use \mintinline{latex}{\usepackage{minted}} for minted inline code.

The listings Package

Basic Code Formatting

\documentclass{article}
\usepackage{listings}
\usepackage{xcolor}

% Basic configuration
\lstset{
  basicstyle=\ttfamily\footnotesize,
  breaklines=true,
  frame=single,
  numbers=left,
  numberstyle=\tiny,
  stepnumber=1,
  showstringspaces=false
}

\begin{document}

\section{Code Examples}

\begin{lstlisting}[language=Python]
def fibonacci(n):
    """Calculate the nth Fibonacci number."""
    if n <= 1:
        return n
    return fibonacci(n-1) + fibonacci(n-2)

# Example usage
for i in range(10):
    print(f"F({i}) = {fibonacci(i)}")
\end{lstlisting}

% Inline code
The function \lstinline|fibonacci(n)| calculates Fibonacci numbers.

\end{document}

Rendered output:

Rendered Output

A code block with a light gray background and single-line frame border. Line numbers (1-10) appear in the left margin in a subtle gray color. The Python code displays in a monospace font with consistent formatting: the function definition, docstring, conditional logic, and loop are all clearly visible with proper indentation preserved.

Language-Specific Styling

\documentclass{article}
\usepackage{listings}
\usepackage{xcolor}

% Python style
\lstdefinestyle{pythonstyle}{
  language=Python,
  basicstyle=\ttfamily\small,
  keywordstyle=\color{blue}\bfseries,
  stringstyle=\color{red},
  commentstyle=\color{gray}\itshape,
  numberstyle=\tiny\color{gray},
  breaklines=true,
  showstringspaces=false,
  frame=leftline,
  framerule=2pt,
  rulecolor=\color{blue!30},
  backgroundcolor=\color{blue!5}
}

% Java style
\lstdefinestyle{javastyle}{
  language=Java,
  basicstyle=\ttfamily\small,
  keywordstyle=\color{purple}\bfseries,
  stringstyle=\color{orange},
  commentstyle=\color{green!60!black}\itshape,
  numberstyle=\tiny\color{gray},
  breaklines=true,
  showstringspaces=false,
  frame=tb,
  framerule=1pt
}

% C++ style
\lstdefinestyle{cppstyle}{
  language=C++,
  basicstyle=\ttfamily\small,
  keywordstyle=\color{blue}\bfseries,
  stringstyle=\color{red!80!black},
  commentstyle=\color{green!60!black}\itshape,
  numberstyle=\tiny\color{gray},
  breaklines=true,
  showstringspaces=false,
  frame=single,
  frameround=tttt
}

\begin{document}

\section{Python Example}
\begin{lstlisting}[style=pythonstyle]
class DataProcessor:
    def __init__(self, data):
        self.data = data
        
    def process(self):
        """Process the data using advanced algorithms."""
        result = []
        for item in self.data:
            if self.validate(item):
                result.append(self.transform(item))
        return result
\end{lstlisting}

\section{Java Example}
\begin{lstlisting}[style=javastyle]
public class Calculator {
    private double result;
    
    public Calculator() {
        this.result = 0.0;
    }
    
    public double add(double value) {
        result += value;
        return result;
    }
    
    public void reset() {
        result = 0.0;
    }
}
\end{lstlisting}

\section{C++ Example}
\begin{lstlisting}[style=cppstyle]
#include <iostream>
#include <vector>
#include <algorithm>

template<typename T>
class Container {
private:
    std::vector<T> data;
    
public:
    void add(const T& item) {
        data.push_back(item);
    }
    
    void sort() {
        std::sort(data.begin(), data.end());
    }
};
\end{lstlisting}

\end{document}

Rendered output:

Rendered Output

Language-specific syntax highlighting - Each style applies different colors and formatting:

Python style: Blue keywords, red strings, gray comments, light blue background with left border
Java style: Purple keywords, orange strings, green comments, top/bottom frame
C++ style: Blue keywords, dark red strings, green comments, rounded frame

The code appears in a monospace font with proper indentation and language-specific keyword coloring.

Custom Language Definitions

\documentclass{article}
\usepackage{listings}
\usepackage{xcolor}

% Define custom language (LaTeX commands)
\lstdefinelanguage{LaTeX}{
  morekeywords={
    documentclass, usepackage, begin, end, section, subsection,
    title, author, maketitle, textbf, textit, emph, label, ref,
    cite, bibliography, includegraphics, caption
  },
  morecomment=[l]{\%},
  morestring=[b]",
  morestring=[b]',
  sensitive=true
}

% Style for LaTeX
\lstdefinestyle{latexstyle}{
  language=LaTeX,
  basicstyle=\ttfamily\small,
  keywordstyle=\color{blue}\bfseries,
  stringstyle=\color{red},
  commentstyle=\color{green!60!black}\itshape,
  breaklines=true,
  showstringspaces=false,
  frame=single,
  backgroundcolor=\color{yellow!10},
  escapeinside={(*@}{@*)}  % Allow LaTeX commands inside
}

% Define SQL language
\lstdefinelanguage{SQL}{
  morekeywords={
    SELECT, FROM, WHERE, INSERT, UPDATE, DELETE, CREATE, TABLE,
    INDEX, PRIMARY, KEY, FOREIGN, REFERENCES, JOIN, INNER, LEFT,
    RIGHT, OUTER, GROUP, BY, ORDER, HAVING, DISTINCT, COUNT, SUM,
    AVG, MAX, MIN, AND, OR, NOT, NULL, TRUE, FALSE
  },
  morecomment=[l]{--},
  morecomment=[s]{/*}{*/},
  morestring=[b]",
  morestring=[b]',
  sensitive=false
}

\begin{document}

\section{LaTeX Code Example}
\begin{lstlisting}[style=latexstyle]
\documentclass{article}
\usepackage{graphicx}
\usepackage{amsmath}

\title{My Document}
\author{John Doe}

\begin{document}
\maketitle

\section{Introduction}
This is an example of (*@\textbf{LaTeX}@*) code formatting.

\begin{equation}
E = mc^2
\end{equation}

\end{document}
\end{lstlisting}

\section{SQL Example}
\begin{lstlisting}[language=SQL, style=javastyle]
-- Create a table for user information
CREATE TABLE users (
    id INTEGER PRIMARY KEY,
    username VARCHAR(50) NOT NULL UNIQUE,
    email VARCHAR(100) NOT NULL,
    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
);

-- Insert sample data
INSERT INTO users (username, email) VALUES
    ('john_doe', 'john_doe_mail'),
    ('jane_smith', 'jane_smith_mail');

-- Query with joins
SELECT u.username, p.title, p.created_at
FROM users u
INNER JOIN posts p ON u.id = p.user_id
WHERE p.published = TRUE
ORDER BY p.created_at DESC;
\end{lstlisting}

\end{document}

The minted Package

Basic minted Setup

The minted package requires Python and Pygments to be installed, and LaTeX must be compiled with the --shell-escape flag. In LaTeX Cloud Studio, this is handled automatically.

\documentclass{article}
\usepackage{minted}

% Global minted settings
\setminted{
  fontsize=\footnotesize,
  linenos,
  breaklines,
  frame=lines,
  framesep=2mm
}

\begin{document}

\section{Python with minted}

\begin{minted}{python}
import numpy as np
import matplotlib.pyplot as plt

def mandelbrot(c, max_iter):
    """Calculate the Mandelbrot set value for complex number c."""
    z = 0
    for n in range(max_iter):
        if abs(z) > 2:
            return n
        z = z*z + c
    return max_iter

# Generate Mandelbrot set
width, height = 800, 600
xmin, xmax = -2.0, 1.0
ymin, ymax = -1.5, 1.5

mandelbrot_set = np.zeros((height, width))
for i in range(height):
    for j in range(width):
        c = complex(xmin + (xmax - xmin) * j / width,
                   ymin + (ymax - ymin) * i / height)
        mandelbrot_set[i, j] = mandelbrot(c, 100)

plt.imshow(mandelbrot_set, extent=[xmin, xmax, ymin, ymax], 
           cmap='hot', origin='lower')
plt.colorbar()
plt.title('Mandelbrot Set')
plt.show()
\end{minted}

\end{document}

Advanced minted Styling

\documentclass{article}
\usepackage{minted}
\usepackage{mdframed}
\usepackage{xcolor}

% Define custom style
\definecolor{codegray}{rgb}{0.95,0.95,0.95}
\definecolor{codeframe}{rgb}{0.7,0.7,0.7}

% Custom environment for highlighted code
\newenvironment{mintedbox}[1]{%
  \begin{mdframed}[
    linecolor=codeframe,
    backgroundcolor=codegray,
    roundcorner=5pt,
    linewidth=1pt,
    innertopmargin=10pt,
    innerbottommargin=10pt,
    innerleftmargin=10pt,
    innerrightmargin=10pt
  ]
  \begin{minted}[
    fontsize=\small,
    linenos,
    breaklines,
    numbersep=5pt,
    gobble=2
  ]{#1}
}{%
  \end{minted}
  \end{mdframed}
}

\begin{document}

\section{Styled Code Blocks}

\begin{mintedbox}{javascript}
  // Advanced JavaScript example with ES6+ features
  class APIClient {
    constructor(baseURL) {
      this.baseURL = baseURL;
      this.headers = {
        'Content-Type': 'application/json',
        'Accept': 'application/json'
      };
    }
    
    async request(endpoint, options = {}) {
      const url = `${this.baseURL}${endpoint}`;
      const config = {
        ...options,
        headers: {
          ...this.headers,
          ...options.headers
        }
      };
      
      try {
        const response = await fetch(url, config);
        
        if (!response.ok) {
          throw new Error(`HTTP ${response.status}: ${response.statusText}`);
        }
        
        return await response.json();
      } catch (error) {
        console.error('API request failed:', error);
        throw error;
      }
    }
    
    // Convenience methods
    get(endpoint) {
      return this.request(endpoint, { method: 'GET' });
    }
    
    post(endpoint, data) {
      return this.request(endpoint, {
        method: 'POST',
        body: JSON.stringify(data)
      });
    }
  }
  
  // Usage example
  const client = new APIClient('https://api.example.com');
  
  client.get('/users')
    .then(users => console.log('Users:', users))
    .catch(error => console.error('Failed to fetch users:', error));
\end{mintedbox}

\section{Rust Example}

\begin{minted}[
  bgcolor=codegray,
  fontsize=\footnotesize,
  linenos,
  breaklines,
  frame=single,
  framerule=0.5pt,
  framesep=3mm
]{rust}
use std::collections::HashMap;
use std::fs::File;
use std::io::{BufRead, BufReader, Result};

#[derive(Debug, Clone)]
pub struct WordCounter {
    counts: HashMap<String, usize>,
    total_words: usize,
}

impl WordCounter {
    pub fn new() -> Self {
        Self {
            counts: HashMap::new(),
            total_words: 0,
        }
    }
    
    pub fn add_word(&mut self, word: &str) {
        let normalized = word.to_lowercase();
        *self.counts.entry(normalized).or_insert(0) += 1;
        self.total_words += 1;
    }
    
    pub fn count_from_file(&mut self, filename: &str) -> Result<()> {
        let file = File::open(filename)?;
        let reader = BufReader::new(file);
        
        for line in reader.lines() {
            let line = line?;
            for word in line.split_whitespace() {
                // Remove punctuation
                let clean_word: String = word
                    .chars()
                    .filter(|c| c.is_alphabetic())
                    .collect();
                
                if !clean_word.is_empty() {
                    self.add_word(&clean_word);
                }
            }
        }
        
        Ok(())
    }
    
    pub fn most_frequent(&self, n: usize) -> Vec<(&String, &usize)> {
        let mut pairs: Vec<_> = self.counts.iter().collect();
        pairs.sort_by(|a, b| b.1.cmp(a.1));
        pairs.into_iter().take(n).collect()
    }
}
\end{minted}

\end{document}

Highlighting Specific Lines

\documentclass{article}
\usepackage{minted}
\usepackage{xcolor}

% Define highlight colors
\definecolor{highlightgray}{rgb}{0.9,0.9,0.9}
\definecolor{highlightyellow}{rgb}{1.0,1.0,0.8}

\begin{document}

\section{Line Highlighting Examples}

\subsection{Highlighting Specific Lines}
\begin{minted}[
  linenos,
  highlightlines={3,7-9},
  highlightcolor=highlightyellow
]{python}
def binary_search(arr, target):
    left, right = 0, len(arr) - 1
    
    while left <= right:  # Main loop condition
        mid = (left + right) // 2
        
        if arr[mid] == target:    # Found target
            return mid            # Return index
        elif arr[mid] < target:   # Target in right half
            left = mid + 1
        else:                     # Target in left half
            right = mid - 1
    
    return -1  # Target not found
\end{minted}

\subsection{Multiple Highlight Ranges}
\begin{minted}[
  linenos,
  highlightlines={1-2,8-10},
  highlightcolor=highlightgray
]{cpp}
#include <iostream>
#include <vector>
#include <algorithm>

int main() {
    std::vector<int> numbers = {64, 34, 25, 12, 22, 11, 90};
    
    std::cout << "Original array: ";
    for (int num : numbers) {
        std::cout << num << " ";
    }
    std::cout << std::endl;
    
    std::sort(numbers.begin(), numbers.end());
    
    std::cout << "Sorted array: ";
    for (int num : numbers) {
        std::cout << num << " ";
    }
    std::cout << std::endl;
    
    return 0;
}
\end{minted}

\end{document}

Code Listings in Floats

Floating Code Listings

\documentclass{article}
\usepackage{minted}
\usepackage{caption}
\usepackage{float}

% Define new float type for code
\newfloat{listing}{tbp}{lol}
\floatname{listing}{Listing}

% Caption setup for listings
\captionsetup[listing]{position=below}

\begin{document}

\section{Algorithm Examples}

Listing~\ref{lst:quicksort} shows an implementation of the quicksort algorithm.

\begin{listing}[H]
\begin{minted}[
  fontsize=\footnotesize,
  linenos,
  frame=single,
  framesep=2mm
]{python}
def quicksort(arr):
    """
    Sorts an array using the quicksort algorithm.
    
    Args:
        arr: List of comparable elements
        
    Returns:
        Sorted list
    """
    if len(arr) <= 1:
        return arr
    
    pivot = arr[len(arr) // 2]
    left = [x for x in arr if x < pivot]
    middle = [x for x in arr if x == pivot]
    right = [x for x in arr if x > pivot]
    
    return quicksort(left) + middle + quicksort(right)

# Example usage
if __name__ == "__main__":
    test_array = [3, 6, 8, 10, 1, 2, 1]
    print(f"Original: {test_array}")
    print(f"Sorted: {quicksort(test_array)}")
\end{minted}
\caption{Quicksort algorithm implementation in Python}
\label{lst:quicksort}
\end{listing}

The algorithm shown in Listing~\ref{lst:quicksort} has an average time complexity of O(n log n).

\begin{listing}[t]
\begin{minted}[
  fontsize=\small,
  linenos,
  frame=leftline,
  framerule=2pt,
  rulecolor=blue
]{java}
public class BinaryTree<T extends Comparable<T>> {
    private Node<T> root;
    
    private static class Node<T> {
        T data;
        Node<T> left, right;
        
        Node(T data) {
            this.data = data;
            this.left = this.right = null;
        }
    }
    
    public void insert(T data) {
        root = insertRec(root, data);
    }
    
    private Node<T> insertRec(Node<T> root, T data) {
        if (root == null) {
            root = new Node<>(data);
            return root;
        }
        
        if (data.compareTo(root.data) < 0) {
            root.left = insertRec(root.left, data);
        } else if (data.compareTo(root.data) > 0) {
            root.right = insertRec(root.right, data);
        }
        
        return root;
    }
    
    public boolean search(T data) {
        return searchRec(root, data);
    }
    
    private boolean searchRec(Node<T> root, T data) {
        if (root == null) {
            return false;
        }
        
        if (data.compareTo(root.data) == 0) {
            return true;
        }
        
        return data.compareTo(root.data) < 0 
            ? searchRec(root.left, data)
            : searchRec(root.right, data);
    }
}
\end{minted}
\caption{Generic binary search tree implementation in Java}
\label{lst:bst}
\end{listing}

\end{document}

Code Listings with Subfigures

\documentclass{article}
\usepackage{minted}
\usepackage{subcaption}
\usepackage{caption}

\begin{document}

\section{Algorithm Comparison}

Figure~\ref{fig:sorting-algorithms} compares different sorting algorithm implementations.

\begin{figure}[htbp]
\centering

\begin{subfigure}[t]{0.45\textwidth}
\begin{minted}[
  fontsize=\tiny,
  linenos,
  frame=single,
  framesep=1mm
]{python}
def bubble_sort(arr):
    """Bubble sort - O(n²)"""
    n = len(arr)
    for i in range(n):
        for j in range(0, n - i - 1):
            if arr[j] > arr[j + 1]:
                arr[j], arr[j + 1] = arr[j + 1], arr[j]
    return arr

# Example
numbers = [64, 34, 25, 12, 22, 11, 90]
print("Bubble sort:", bubble_sort(numbers.copy()))
\end{minted}
\caption{Bubble sort algorithm}
\label{fig:bubble-sort}
\end{subfigure}
\hfill
\begin{subfigure}[t]{0.45\textwidth}
\begin{minted}[
  fontsize=\tiny,
  linenos,
  frame=single,
  framesep=1mm
]{python}
def merge_sort(arr):
    """Merge sort - O(n log n)"""
    if len(arr) <= 1:
        return arr
    
    mid = len(arr) // 2
    left = merge_sort(arr[:mid])
    right = merge_sort(arr[mid:])
    
    return merge(left, right)

def merge(left, right):
    result = []
    i = j = 0
    
    while i < len(left) and j < len(right):
        if left[i] <= right[j]:
            result.append(left[i])
            i += 1
        else:
            result.append(right[j])
            j += 1
    
    result.extend(left[i:])
    result.extend(right[j:])
    return result

# Example
numbers = [64, 34, 25, 12, 22, 11, 90]
print("Merge sort:", merge_sort(numbers.copy()))
\end{minted}
\caption{Merge sort algorithm}
\label{fig:merge-sort}
\end{subfigure}

\caption{Comparison of sorting algorithms with different time complexities}
\label{fig:sorting-algorithms}
\end{figure}

\end{document}

Inline Code and Escaping

Inline Code with Special Characters

\documentclass{article}
\usepackage{minted}
\usepackage{listings}

% Configure listings for inline code
\lstset{
  basicstyle=\ttfamily,
  breaklines=true
}

\begin{document}

\section{Inline Code Examples}

% Simple inline code
The \lstinline|print()| function outputs text to the console.

% Inline code with special characters
Use \lstinline|arr[i] = arr[j]| to swap array elements.

% Different delimiters for special characters
The regular expression \lstinline/[a-zA-Z0-9]+/ matches alphanumeric strings.

% Minted inline code
The \mintinline{python}|lambda x: x**2| function squares its input.

% Inline code with highlighting
The key function is \mintinline[bgcolor=yellow!30]{python}|process_data()|.

\section{Code with LaTeX Escapes}

\begin{lstlisting}[language=Python, escapeinside={(*@}{@*)}]
def calculate_(*@\textbf{mean}@*)(values):
    """Calculate the arithmetic (*@\emph{mean}@*) of a list."""
    if not values:
        return 0
    return sum(values) / len(values)  # (*@$\frac{\sum x_i}{n}$@*)

# Example: (*@\textcolor{red}{Important note}@*)
result = calculate_mean([1, 2, 3, 4, 5])
print(f"Mean: {result}")  # Output: (*@\texttt{Mean: 3.0}@*)
\end{lstlisting}

\end{document}

Performance and Customization

Custom Color Schemes

\documentclass{article}
\usepackage{minted}
\usepackage{xcolor}

% Define custom color scheme
\definecolor{darkblue}{rgb}{0.0,0.2,0.4}
\definecolor{darkgreen}{rgb}{0.0,0.4,0.2}
\definecolor{darkred}{rgb}{0.4,0.0,0.2}
\definecolor{darkorange}{rgb}{0.8,0.4,0.0}
\definecolor{codebg}{rgb}{0.98,0.98,0.98}

% Custom minted style
\newminted{python}{
  bgcolor=codebg,
  fontsize=\footnotesize,
  linenos,
  numbersep=8pt,
  frame=leftline,
  framerule=2pt,
  rulecolor=darkblue,
  breaklines,
  breaksymbolleft=\raisebox{0.8ex}{\small\reflectbox{\carriagereturn}},
  breaksymbolindentleft=0pt,
  breaksymbolsepleft=0pt,
  breaksymbolright=\small\carriagereturn,
  breaksymbolindentright=0pt,
  breaksymbolsepright=0pt
}

% Custom environment
\newenvironment{darkcode}
{%
  \begin{tcolorbox}[
    colback=black!95,
    coltext=white,
    colframe=gray!50,
    arc=2mm,
    boxrule=0.5pt
  ]
  \begin{minted}[
    bgcolor={},
    fontsize=\small,
    style=monokai
  ]{python}
}{%
  \end{minted}
  \end{tcolorbox}
}

\begin{document}

\section{Custom Styled Code}

\begin{pythoncode}
import asyncio
import aiohttp
from typing import List, Dict, Optional

class AsyncWebScraper:
    def __init__(self, max_concurrent: int = 10):
        self.max_concurrent = max_concurrent
        self.session: Optional[aiohttp.ClientSession] = None
        
    async def __aenter__(self):
        connector = aiohttp.TCPConnector(limit=self.max_concurrent)
        self.session = aiohttp.ClientSession(connector=connector)
        return self
        
    async def __aexit__(self, exc_type, exc_val, exc_tb):
        if self.session:
            await self.session.close()
            
    async def fetch_url(self, url: str) -> Dict[str, str]:
        """Fetch content from a single URL."""
        try:
            async with self.session.get(url) as response:
                content = await response.text()
                return {
                    'url': url,
                    'status': response.status,
                    'content': content[:1000],  # First 1000 chars
                    'headers': dict(response.headers)
                }
        except Exception as e:
            return {
                'url': url,
                'error': str(e),
                'status': None,
                'content': None
            }
    
    async def scrape_urls(self, urls: List[str]) -> List[Dict[str, str]]:
        """Scrape multiple URLs concurrently."""
        tasks = [self.fetch_url(url) for url in urls]
        results = await asyncio.gather(*tasks, return_exceptions=True)
        return [r for r in results if not isinstance(r, Exception)]

# Usage example
async def main():
    urls = [
        'https://httpbin.org/json',
        'https://httpbin.org/xml',
        'https://httpbin.org/html'
    ]
    
    async with AsyncWebScraper(max_concurrent=5) as scraper:
        results = await scraper.scrape_urls(urls)
        
    for result in results:
        print(f"URL: {result['url']}")
        print(f"Status: {result.get('status', 'Error')}")
        print("-" * 50)

if __name__ == "__main__":
    asyncio.run(main())
\end{pythoncode}

\end{document}

Code Import from Files

\documentclass{article}
\usepackage{minted}

\begin{document}

\section{Importing Code from Files}

% Import entire file
\inputminted{python}{example_script.py}

% Import specific lines from file
\inputminted[firstline=10,lastline=25]{python}{large_script.py}

% Import with custom styling
\inputminted[
  fontsize=\footnotesize,
  linenos,
  numbersep=5pt,
  frame=lines,
  framesep=2mm,
  bgcolor=gray!10
]{python}{algorithm.py}

\section{Code Snippets}

% You can also use external command to include processed code
\immediate\write18{pygmentize -l python -f latex example.py > example_highlighted.tex}
\input{example_highlighted.tex}

\end{document}

Best Practices

Code formatting guidelines:

Choose appropriate package - Use listings for simple formatting, minted for syntax highlighting
Consistent styling - Define styles once and reuse throughout document
Font size - Use \footnotesize or \small for better readability
Line numbers - Include for longer code blocks, omit for short snippets
Break long lines - Enable breaklines for better page layout
Escape special characters - Use proper delimiters for inline code

Production-Ready Setup

\documentclass{article}
\usepackage{minted}
\usepackage{tcolorbox}
\usepackage{caption}

% Global minted configuration
\setminted{
  fontsize=\footnotesize,
  linenos=true,
  numbersep=8pt,
  frame=leftline,
  framerule=1pt,
  breaklines=true,
  breaksymbolleft=\raisebox{0.8ex}{\small\reflectbox{\carriagereturn}},
  autogobble=true
}

% Professional code environment
\newtcolorbox{codebox}[2][]{
  colback=blue!5!white,
  colframe=blue!50!black,
  title=#2,
  fonttitle=\bfseries,
  #1
}

% Language-specific environments
\newenvironment{pythoncode}[1][]
{%
  \begin{codebox}[#1]{Python Code}
  \begin{minted}{python}
}{%
  \end{minted}
  \end{codebox}
}

\newenvironment{javacode}[1][]
{%
  \begin{codebox}[colback=orange!5!white,colframe=orange!50!black,#1]{Java Code}
  \begin{minted}{java}
}{%
  \end{minted}
  \end{codebox}
}

\begin{document}

\section{Professional Code Presentation}

\begin{pythoncode}[title=Data Analysis Pipeline]
import pandas as pd
import numpy as np
from sklearn.preprocessing import StandardScaler
from sklearn.model_selection import train_test_split
from sklearn.ensemble import RandomForestClassifier
from sklearn.metrics import classification_report, confusion_matrix

class DataAnalysisPipeline:
    """A complete data analysis pipeline for machine learning."""
    
    def __init__(self, random_state=42):
        self.random_state = random_state
        self.scaler = StandardScaler()
        self.model = RandomForestClassifier(
            n_estimators=100,
            random_state=self.random_state
        )
        self.is_fitted = False
        
    def preprocess_data(self, X, y=None, fit_transform=True):
        """Preprocess the input data."""
        if fit_transform:
            X_scaled = self.scaler.fit_transform(X)
        else:
            X_scaled = self.scaler.transform(X)
            
        return X_scaled
        
    def train(self, X, y, test_size=0.2):
        """Train the model with the provided data."""
        # Split the data
        X_train, X_test, y_train, y_test = train_test_split(
            X, y, test_size=test_size, random_state=self.random_state
        )
        
        # Preprocess
        X_train_scaled = self.preprocess_data(X_train, fit_transform=True)
        X_test_scaled = self.preprocess_data(X_test, fit_transform=False)
        
        # Train model
        self.model.fit(X_train_scaled, y_train)
        self.is_fitted = True
        
        # Evaluate
        train_score = self.model.score(X_train_scaled, y_train)
        test_score = self.model.score(X_test_scaled, y_test)
        
        return {
            'train_score': train_score,
            'test_score': test_score,
            'X_test': X_test_scaled,
            'y_test': y_test
        }
        
    def predict(self, X):
        """Make predictions on new data."""
        if not self.is_fitted:
            raise ValueError("Model must be trained before making predictions")
            
        X_scaled = self.preprocess_data(X, fit_transform=False)
        return self.model.predict(X_scaled)
        
    def feature_importance(self):
        """Get feature importance scores."""
        if not self.is_fitted:
            raise ValueError("Model must be trained first")
            
        return self.model.feature_importances_

# Example usage
if __name__ == "__main__":
    # Load your dataset here
    # X, y = load_your_data()
    
    pipeline = DataAnalysisPipeline()
    results = pipeline.train(X, y)
    
    print(f"Training accuracy: {results['train_score']:.3f}")
    print(f"Testing accuracy: {results['test_score']:.3f}")
\end{pythoncode}

\end{document}

Troubleshooting & FAQ

minted Error: shell escape enabled (or -shell-escape)?

Most minted errors happen when LaTeX isn’t compiled with shell-escape. Fix by compiling with --shell-escape (or enable it in your editor). In LaTeX Cloud Studio, shell-escape is enabled automatically for minted.

Do I need Python and Pygments installed?

Yes. minted uses Pygments (a Python library) for syntax highlighting. On local setups, install python3 and pygments and compile with --shell-escape. Cloud Studio manages this for you.

minted vs listings – which should I use?

Use listings for lightweight, dependency-free code blocks; choose minted for high-quality syntax highlighting and extensive styling. For journal-ready output, minted is usually preferred.

How do I avoid shell-escape for strict environments?

Use listings instead of minted, or pre-generate highlighted code externally and include as verbatim. Some journals forbid shell-escape; listings is safe.

Colored backgrounds and line highlighting don’t appear

Ensure your document isn’t forcing monochrome (e.g., via print mode) and that options like bgcolor, highlightlines, and frame are set on the environment or via \setminted{...}.

Quick Reference

Essential Commands

Package	Command	Purpose	Example
listings	`\lstset{}`	Global configuration	`\lstset{language=Python}`
listings	`\begin{lstlisting}`	Code block	`\begin{lstlisting}[language=Java]`
listings	`\lstinline`	Inline code	`\lstinline	code	`
minted	`\setminted{}`	Global configuration	`\setminted{fontsize=\small}`
minted	`\begin{minted}`	Code block	`\begin{minted}{python}`
minted	`\mintinline`	Inline code	`\mintinline	code	`

Common Options

Option	Effect	Example
`language`	Set programming language	`language=Python`
`linenos`	Show line numbers	`linenos=true`
`fontsize`	Set font size	`fontsize=\footnotesize`
`breaklines`	Allow line breaking	`breaklines=true`
`frame`	Add frame around code	`frame=single`
`bgcolor`	Background color	`bgcolor=gray!10`

Supported Languages

Both packages support many languages including:

Python, Java, C++, C, JavaScript, TypeScript
HTML, CSS, SQL, LaTeX, Bash, PowerShell
Go, Rust, Swift, Kotlin, Scala, Haskell
MATLAB, R, Julia, Perl, Ruby, PHP

Next: Learn about Headers and footers for page decoration and numbering, or explore Multiple columns for layout.

Getting Started

LaTeX Basics

Text & Formatting

Mathematics

Figures & Tables

Specialized Notation

Bibliography & References

Document Structure

Languages

Advanced Topics

​listings vs minted

​Quick Start

​Minimal listings setup

​Minimal minted setup

​The usual minted failure

​Inline code

​The listings Package

​Basic Code Formatting

Rendered Output

​Language-Specific Styling

Rendered Output

​Custom Language Definitions

​The minted Package

​Basic minted Setup

​Advanced minted Styling

​Highlighting Specific Lines

​Code Listings in Floats

​Floating Code Listings

​Code Listings with Subfigures

​Inline Code and Escaping

​Inline Code with Special Characters

​Performance and Customization

​Custom Color Schemes

​Code Import from Files

​Best Practices

​Production-Ready Setup

​Troubleshooting & FAQ

​Quick Reference

​Essential Commands

​Common Options

​Supported Languages

listings vs minted

Quick Start

Minimal `listings` setup

Minimal `minted` setup

The usual `minted` failure

Inline code

The listings Package

Basic Code Formatting

Language-Specific Styling

Custom Language Definitions

The minted Package

Basic minted Setup

Advanced minted Styling

Highlighting Specific Lines

Code Listings in Floats

Floating Code Listings

Code Listings with Subfigures

Inline Code and Escaping

Inline Code with Special Characters

Performance and Customization

Custom Color Schemes

Code Import from Files

Best Practices

Production-Ready Setup

Troubleshooting & FAQ

Quick Reference

Essential Commands

Common Options

Supported Languages