Aspose TeX for Python – FAQ

Q: What is Aspose TeX for Python?

A: Aspose TeX for Python is a pure‑Python API (built on top of the Aspose TeX .NET library via pythonnet) that renders and converts LaTeX/TeX documents to PDF, XPS, SVG, PNG, JPEG, BMP, TIFF and other image formats without requiring any external TeX distribution. It runs in‑process and is suited for web services, desktop apps, and automated report generators.

Q: How do I install Aspose TeX for Python?

A: Run pip install aspose-tex-python-net. The package bundles the required pythonnet runtime automatically. Install it inside any virtual environment (Windows, Linux, macOS) with Python 3.8 or later. Verify the installation with:

import aspose.tex as tex
print(tex.__version__)

Q: Do I need a local TeX distribution (MiKTeX, TeX Live, etc.)?

A: No. All parsing and rendering logic is built into Aspose TeX, so you never need an external TeX engine. The library includes over 300 core LaTeX packages and common class files out of the box.

Q: How can I convert a .tex file to PDF with a few lines of code?

A: Create a TeXJob with the Object LaTeX configuration, PdfSaveOptions and a PdfDevice. Set ASPOSE_TEX_INPUT_FILE to your input file and ASPOSE_TEX_OUTPUT_DIR to the output directory, or edit the default paths. Apply a license before conversion as described in Licensing.

# Convert LaTeX to PDF.
import os
from pathlib import Path
from aspose.tex import Interaction, TeXConfig, TeXJob, TeXOptions
from aspose.tex.io import InputFileSystemDirectory, OutputFileSystemDirectory, OutputMemoryTerminal
from aspose.tex.presentation.pdf import PdfDevice, PdfSaveOptions

# Set these paths to your LaTeX document and output directory.
input_file = Path(os.environ.get("ASPOSE_TEX_INPUT_FILE", "hello-world.ltx")).resolve()
output_dir = Path(os.environ.get("ASPOSE_TEX_OUTPUT_DIR", "output")).resolve()
if not input_file.is_file():
    raise FileNotFoundError(input_file)
output_dir.mkdir(parents=True, exist_ok=True)

# Use the Object LaTeX format and resolve additional inputs beside the main file.
options = TeXOptions.console_app_options(TeXConfig.object_latex)
options.input_working_directory = InputFileSystemDirectory(str(input_file.parent))
options.output_working_directory = OutputFileSystemDirectory(str(output_dir))
options.interaction = Interaction.NONSTOP_MODE
options.terminal_out = OutputMemoryTerminal()
options.save_options = PdfSaveOptions()
device = PdfDevice()
job_result = TeXJob(str(input_file), device, options).run()

The default output filename follows the input stem: hello-world.ltx produces hello-world.pdf. See LaTeX to PDF for details.

Q: Which output formats can Aspose TeX for Python generate?

A: PDF, XPS, SVG, PNG, JPEG, BMP, and TIFF. Each format can be controlled via specific SaveOptions objects (e.g., PdfSaveOptions, PngSaveOptions, SvgSaveOptions).

Q: How do I embed custom fonts into the generated PDF?

A: Fonts are selected by the TeX or LaTeX document and its packages. For package resources, see External LaTeX packages. To control whether only used glyphs are embedded, use the subset_fonts property of PdfSaveOptions; this is different from selecting a custom font. See Subsetting fonts for a complete XPS example using the same option.

Q: What LaTeX packages and classes are supported out of the box?

A: The library includes common LaTeX packages and classes. Consult the embedded package list for coverage. The external package example for pgfplots supplies its package sources externally through required_input_directory.

Q: How can I use a third‑party .sty or class file that is not built‑in?

A: Set TeXOptions.required_input_directory to an InputFileSystemDirectory containing the required package files. The complete example below loads fancybox.sty from ExternalLaTeXPackages/packages and converts required-input-fs.tex to PNG. Set ASPOSE_TEX_INPUT_DIR to the parent of ExternalLaTeXPackages (default: input) and ASPOSE_TEX_OUTPUT_DIR to the output folder (default: output). Apply a license first.

# Load an external LaTeX package from a directory.
import os
from pathlib import Path
from os import path
from io import BytesIO
from aspose.tex import Interaction, TeXConfig, TeXJob, TeXOptions
from aspose.tex.io import InputFileSystemDirectory, InputZipDirectory, OutputFileSystemDirectory, OutputMemoryTerminal
from aspose.tex.presentation.image import ImageDevice, PngSaveOptions

output_dir = Path(os.environ.get("ASPOSE_TEX_OUTPUT_DIR", "output")).resolve()
output_dir.mkdir(parents=True, exist_ok=True)
input_dir = Path(os.environ.get("ASPOSE_TEX_INPUT_DIR", "input")).resolve() / "ExternalLaTeXPackages"
# Create conversion options for Object LaTeX format upon Object TeX engine extension.
options = TeXOptions.console_app_options(TeXConfig.object_latex)
options.interaction = Interaction.NONSTOP_MODE
options.terminal_out = OutputMemoryTerminal()
# Specify a file system working directory for the output.
options.output_working_directory = OutputFileSystemDirectory(str(output_dir))
# Specify a file system working directory for the required input.
# The directory containing packages may be located anywhere.
options.required_input_directory = InputFileSystemDirectory(path.join(str(input_dir), "packages"))
# Initialize the options for saving in PNG format.
options.save_options = PngSaveOptions()
# Run LaTeX to PNG conversion.
TeXJob(path.join(str(input_dir), "required-input-fs.tex"), ImageDevice(True), options).run()

For ZIP archives and package compatibility restrictions, see External LaTeX packages.

Q: What are the main limitations of the engine?

A:

Limitation	Details
Shell escape (\write18)	Disabled for security.
Full TikZ externalization	Not supported; most TikZ graphics render in‑process, but extremely complex drawings may fail.
Unicode font coverage	Only TrueType/OpenType fonts with complete glyph sets are fully supported; legacy Type 1 fonts may need conversion.
Very large documents (> 500 pages)	Can consume significant memory; consider streaming pages with Document.save(output_stream, options).

Q: How do I apply a license key and what licensing models are available?

A: Apply the license before using other Aspose.TeX classes. Set ASPOSE_TEX_PYTHON_NET_LICENSE_PATH to your license file, or place Aspose.TeX.Python-net.lic in the working directory:

# Apply a license from a file before using other Aspose.TeX classes.
import os
from aspose.tex import License

# Set this environment variable, or place the license in the working directory.
license_path = os.environ.get(
    "ASPOSE_TEX_PYTHON_NET_LICENSE_PATH", "Aspose.TeX.Python-net.lic"
)
license = License()
license.set_license(license_path)

For file, stream and metered examples and evaluation limitations, see Licensing.

Q: Is the library thread‑safe for parallel conversions?

A: Yes, provided each thread creates its own Document instance. Static objects such as the License must be set before any parallel work starts.

Q: Which .NET runtime version does Aspose TeX for Python require?

A: The package ships with the .NET 6 (x64) runtime binaries. They are loaded automatically by pythonnet on the first import; you do not need to install .NET manually.

Q: How can I set page size, orientation, and DPI for raster outputs?

A: Define page size and orientation in the LaTeX source. For example, save this A4 landscape document as landscape.ltx:

\documentclass{article}
\usepackage[a4paper,landscape]{geometry}
\begin{document}
Hello, World!
\end{document}

Set PngSaveOptions.resolution before assigning the save options to the job. This example uses 300 DPI. Set ASPOSE_TEX_INPUT_FILE to landscape.ltx and ASPOSE_TEX_OUTPUT_DIR to your output directory, or use the example’s default paths:

# Convert an A4 landscape LaTeX document to PNG at 300 DPI.
import os
from pathlib import Path
from aspose.tex import Interaction, TeXConfig, TeXJob, TeXOptions
from aspose.tex.io import InputFileSystemDirectory, OutputFileSystemDirectory, OutputMemoryTerminal
from aspose.tex.presentation.image import ImageDevice, PngSaveOptions

# Set these paths to your LaTeX document and output directory.
input_file = Path(os.environ.get("ASPOSE_TEX_INPUT_FILE", "landscape.ltx")).resolve()
output_dir = Path(os.environ.get("ASPOSE_TEX_OUTPUT_DIR", "output")).resolve()
if not input_file.is_file():
    raise FileNotFoundError(input_file)
output_dir.mkdir(parents=True, exist_ok=True)

# Use the Object LaTeX format and resolve additional inputs beside the main file.
options = TeXOptions.console_app_options(TeXConfig.object_latex)
options.input_working_directory = InputFileSystemDirectory(str(input_file.parent))
options.output_working_directory = OutputFileSystemDirectory(str(output_dir))
options.interaction = Interaction.NONSTOP_MODE
options.terminal_out = OutputMemoryTerminal()
# Page size and orientation are defined in the LaTeX input (geometry package).
# Set the raster resolution in dots per inch.
save_options = PngSaveOptions()
save_options.resolution = 300
options.save_options = save_options
device = ImageDevice(True)
job_result = TeXJob(str(input_file), device, options).run()

The result is landscape.png, approximately 3508 by 2480 pixels.

Q: Can I render LaTeX directly from a string or an in‑memory stream?

A: Encode a complete LaTeX document into a binary BytesIO stream and pass it to TeXJob with TeXConfig.object_latex. Set ASPOSE_TEX_OUTPUT_DIR to the output folder, or use the default output. Apply a license first as described in Licensing.

# Render LaTeX supplied as a binary in-memory stream to XPS.
import os
from pathlib import Path
from aspose.tex import Interaction, TeXConfig, TeXJob, TeXOptions
from io import BytesIO
from aspose.tex.io import OutputFileSystemDirectory, OutputMemoryTerminal
from aspose.tex.presentation.xps import XpsDevice

output_dir = Path(os.environ.get("ASPOSE_TEX_OUTPUT_DIR", "output")).resolve()
output_dir.mkdir(parents=True, exist_ok=True)

options = TeXOptions.console_app_options(TeXConfig.object_latex)
options.interaction = Interaction.NONSTOP_MODE
options.output_working_directory = OutputFileSystemDirectory(str(output_dir))
options.terminal_out = OutputMemoryTerminal()
latex_source = r"\documentclass{article} \begin{document} Hello, World! \end{document}"
device = XpsDevice()
with BytesIO(latex_source.encode("ascii")) as input_stream:
    job_result = TeXJob(input_stream, device, options).run()

The example creates texput.xps and texput.log. See Other ways to provide main input for details.

Q: Where can I find official documentation, code samples, and support channels?

A: Check the next resources:

• Official Documentation
• Getting Started Guide
• Code Samples & GitHub Gists
• Support Forum
• Issue Tracker (private for customers) - Provided after purchase

All examples are available in both Python and C#; the C# code can be directly translated thanks to pythonnet.