KAHIBARO Bookshelves
Discord Login Register

13.5. Sharing and Exporting Live Scripts

Why Share and Export Live Scripts

Live scripts are designed to be shared. They combine code, text, equations, and output in one file, so they are ideal for teaching, reports, and collaboration. However, not everyone you work with will have MATLAB, or the same version, so you often need to export your live script into other formats.

This chapter focuses on what is specific to sharing and exporting live scripts: how to turn a .mlx file into other documents, how to control what gets exported, and how to distribute your work to others both inside and outside MATLAB.

The `.mlx` File and Compatibility

A live script is stored as a .mlx file. This is the native format for MATLAB live scripts and is the best way to preserve everything, including:

text formatting, headings, and lists
equations written in the editor
interactive controls such as sliders
embedded images and rich outputs

If you share a .mlx file with someone who has MATLAB, they can open it directly in the Live Editor, run and edit it, and see all features.

If they have an older version of MATLAB, some newer Live Editor features might not appear exactly the same. When working with collaborators, it is often helpful to check that you are using compatible MATLAB releases, or to keep the live script simple if the recipient uses an older version.

Exporting Live Scripts to PDF, HTML, and Word

Often you want to share the results, not the code environment. Live scripts can be exported to common document formats from within MATLAB.

To export using the graphical interface, open your live script, then use the Live Editor export options. Depending on the version, this is usually found through the Live Editor tab or the Save or Export controls. You choose a target format such as PDF, HTML, or Microsoft Word.

Export to PDF is useful when you want a fixed, print-ready document. The layout is preserved, including headings, code, output, figures, and equations. Readers do not need MATLAB or any special software beyond a PDF viewer. PDF is not easily editable, which is sometimes desirable for finalized reports.

Export to HTML is suited for web based viewing. The result is an HTML file that can be opened in any web browser. Code, formatted text, and figures are visible, and the document can be scrolled like a web page. HTML output can be shared by email or placed on a website or internal documentation portal. It is also convenient when you want a lightweight, cross platform format.

Export to Word creates a .docx file that can be opened and edited in Microsoft Word or other compatible word processors. The main structure of your live script appears as a document with code blocks, outputs, text, and images. This is useful when collaborators want to add comments, track changes, or integrate your analysis into a larger written report.

In all of these exports, interactive elements such as sliders or buttons are turned into static content. They appear in the exported document, but they cannot be adjusted or executed outside MATLAB.

Exporting to MATLAB Code Files

Sometimes you want to share the logic and structure of your live script as a plain code file, for example to use in automated scripts or with colleagues who prefer the classic editor.

You can convert a live script to a standard .m file. When you do this, MATLAB keeps the code sections and comments, but removes the rich formatting. Text paragraphs become commented lines, formatted as % comments. Equations become commented text, not live mathematical objects. Plots and generated outputs are not stored, since the .m file only keeps code.

This conversion is useful when you want to:

run the code on older MATLAB versions that do not support live scripts
use the script in batch processing or another environment that expects .m files
share a simple, code only version for review or integration into a larger code base

Because the .m file does not contain outputs, readers must run it to reproduce results. For reviews, you might want to send both a .m file and an exported PDF or HTML file.

Controlling What Gets Exported

Before exporting, you can control what appears in the final document. Typically, the Live Editor gives you options such as whether to include code, output, or both. You may also be able to export only selected sections.

Including both code and output is useful for teaching, tutorials, and reproducible reports. Readers see exactly which commands produced which results. This is the default choice for many workflows.

Including only output hides the code and focuses on results, figures, and explanations. This is helpful when the audience is not interested in MATLAB programming, such as managers, clients, or non technical colleagues.

Including only code is rare for document oriented formats like PDF, but it can be helpful if you are preparing a handout for code review or if you want to distribute a version that students or colleagues must run themselves.

If you have long running sections or heavy computations, it is often a good idea to run the live script once, verify the results, and then export with the outputs already present. That way, the exported document includes the final state without needing to execute anything during export.

Sharing Live Scripts with Colleagues

When your collaborators have MATLAB, the simplest way to share is to send the .mlx file directly, for example by email or through a shared folder or project. Recipients can open the file, explore the contents, and re run sections as needed.

For group work, organizing live scripts in a shared folder structure helps keep projects clear. Each live script can serve as a narrative and executable description of part of the project. Using consistent section headers inside the live scripts also makes navigation easier.

When live scripts are part of a larger project with multiple .m functions and data files, remember that sharing just the .mlx file is often not enough. You also need to include any custom functions, data, or helper files that the live script uses, and ensure the paths are set appropriately when others open the project.

Sharing Live Scripts Without MATLAB

If the recipient does not have MATLAB, the .mlx file alone is not sufficient. In that case you rely on exported formats.

For sharing with non technical stakeholders, PDF is often the best choice. It is readable on almost any device and keeps the layout very close to what you see in the Live Editor.

For sharing on websites, learning platforms, or internal documentation portals, HTML export is often more convenient. The HTML file can be embedded or linked, and users only need a browser.

If the recipient needs to modify the text or integrate it into another document, Word export is appropriate. They can edit the .docx file, add commentary, or reformat sections.

In some environments, you might also compress your project folder, including the exported documents and any data, into a single archive file for easy distribution.

Exporting Figures from Live Scripts

Live scripts often contain plots and other visual output. These figures can be used separately in slides, papers, or reports.

When you export a live script to PDF, HTML, or Word, the figures are included automatically in the resulting document. However, you may sometimes need individual image files, such as .png or .jpg, for use in presentation software.

To do this, you typically use standard figure export tools. You can open a figure generated in the live script and then use MATLAB graphics export features, either interactively from the figure window or programmatically using functions that save figures to disk. The live script itself remains the place where the figures are created and configured, while the exported images are used externally.

Reproducibility and Sharing Data Alongside Live Scripts

When you share a live script, think about whether someone else can reproduce the results. If the live script depends on local data files, external paths, or specific toolbox functions, others may not get the same outcome when they run it.

To improve reproducibility when sharing, keep your data files in known locations relative to the live script, avoid hard coded absolute paths, and document any toolbox requirements in the introductory text section of the live script. If possible, include small sample data sets with the script, or clearly state where the data can be obtained.

When exporting to PDF or HTML, you preserve the results as they existed at the time of export, even if others cannot rerun the analysis. When sharing the .mlx file itself, also sharing the data and describing any prerequisites helps others run and extend your work.

Summary of Key Points

Views: 0

Comments

Please login to add a comment.

Don't have an account? Register now!

Where to Move

Move chapter:

  • ☰ 1. Getting Started with MATLAB
    • ☰ 1.1. What Is MATLAB and What Is It Used For
      • ☰ 1.2. Installing MATLAB and Setting Up the Environment
        • ☰ 1.3. Understanding the MATLAB Desktop Interface
          • ☰ 1.4. Command Window, Workspace, and Current Folder
            • ☰ 1.5. Basic Workflow and Running Simple Commands
              • ☰ 1.6. Getting Help and Documentation
              • ☰ 2. MATLAB Language Basics
                • ☰ 2.1. MATLAB Syntax and Expressions
                  • ☰ 2.2. Variables and Assignment
                    • ☰ 2.3. Data Types and Type Conversion
                      • ☰ 2.4. Vectors and Matrices Fundamentals
                        • ☰ 2.5. Creating and Indexing Arrays
                          • ☰ 2.6. Basic Arithmetic and Elementwise Operations
                            • ☰ 2.7. Using Built-In Constants and Functions
                            • ☰ 3. Working with Variables and the Workspace
                              • ☰ 3.1. Creating, Viewing, and Editing Variables
                                • ☰ 3.2. Workspace Browser and Variable Inspector
                                  • ☰ 3.3. Saving and Loading Data Files
                                    • ☰ 3.4. MAT-Files and Importing External Data
                                      • ☰ 3.5. Clearing Variables and Managing the Workspace
                                      • ☰ 4. Vectors, Matrices, and Arrays
                                        • ☰ 4.1. Row and Column Vectors
                                          • ☰ 4.2. Matrix Creation and Concatenation
                                            • ☰ 4.3. Indexing, Slicing, and Logical Indexing
                                              • ☰ 4.4. Matrix Operations vs Elementwise Operations
                                                • ☰ 4.5. Reshaping and Rearranging Arrays
                                                  • ☰ 4.6. Special Matrices and Functions
                                                  • ☰ 5. Basic Programming Constructs
                                                    • ☰ 5.1. Scripts vs Functions
                                                      • ☰ 5.2. Control Flow with if, elseif, else
                                                        • ☰ 5.3. Loops with for and while
                                                          • ☰ 5.4. break, continue, and return
                                                            • ☰ 5.5. Logical Expressions and Relational Operators
                                                              • ☰ 5.6. Best Practices for Clear and Readable Code
                                                              • ☰ 6. Functions in MATLAB
                                                                • ☰ 6.1. Creating Simple Functions
                                                                  • ☰ 6.2. Function Inputs and Outputs
                                                                    • ☰ 6.3. Function Files and the Path
                                                                      • ☰ 6.4. Local vs Global Variables
                                                                        • ☰ 6.5. Anonymous Functions
                                                                          • ☰ 6.6. Organizing Code into Multiple Functions
                                                                          • ☰ 7. Working with Numbers and Math
                                                                            • ☰ 7.1. Scalars and Vectorized Computations
                                                                              • ☰ 7.2. Basic Mathematical Functions
                                                                                • ☰ 7.3. Trigonometric and Exponential Functions
                                                                                  • ☰ 7.4. Complex Numbers in MATLAB
                                                                                    • ☰ 7.5. Rounding, Modulo, and Special Values
                                                                                      • ☰ 7.6. Numerical Precision and Floating Point Considerations
                                                                                      • ☰ 8. Strings, Characters, and Categorical Data
                                                                                        • ☰ 8.1. Character Arrays and String Arrays
                                                                                          • ☰ 8.2. Creating and Manipulating Strings
                                                                                            • ☰ 8.3. Converting Between Data Types and Strings
                                                                                              • ☰ 8.4. Comparing and Searching Strings
                                                                                                • ☰ 8.5. Categorical Arrays Basics
                                                                                                • ☰ 9. Tables, Structures, and Cell Arrays
                                                                                                  • ☰ 9.1. Introduction to Tables
                                                                                                    • ☰ 9.2. Creating Tables and Accessing Data
                                                                                                      • ☰ 9.3. Modifying and Joining Tables
                                                                                                        • ☰ 9.4. Structures and Nested Structures
                                                                                                          • ☰ 9.5. Cell Arrays and Cell Indexing
                                                                                                            • ☰ 9.6. Choosing the Right Container Type
                                                                                                            • ☰ 10. Importing and Exporting Data
                                                                                                              • ☰ 10.1. Reading Text and CSV Files
                                                                                                                • ☰ 10.2. Importing Excel Spreadsheets
                                                                                                                  • ☰ 10.3. Importing Data with the Import Tool
                                                                                                                    • ☰ 10.4. Exporting Data to Files
                                                                                                                      • ☰ 10.5. Working with Image and Audio Files
                                                                                                                        • ☰ 10.6. Basic File Management from MATLAB
                                                                                                                        • ☰ 11. Plotting and Visualization
                                                                                                                          • ☰ 11.1. Introduction to 2D Plotting
                                                                                                                            • ☰ 11.2. Customizing Plots and Axes
                                                                                                                              • ☰ 11.3. Multiple Plots in One Figure
                                                                                                                                • ☰ 11.4. Labels, Titles, Legends, and Annotations
                                                                                                                                  • ☰ 11.5. Plotting with Different Line and Marker Styles
                                                                                                                                    • ☰ 11.6. Saving and Exporting Figures
                                                                                                                                    • ☰ 12. Advanced Plotting for Beginners
                                                                                                                                      • ☰ 12.1. Subplots and Tiled Layouts
                                                                                                                                        • ☰ 12.2. Bar, Scatter, and Stem Plots
                                                                                                                                          • ☰ 12.3. Histograms and Density Plots
                                                                                                                                            • ☰ 12.4. 3D Plots and Surface Plots
                                                                                                                                              • ☰ 12.5. Using plottools and Interactive Editing
                                                                                                                                                • ☰ 12.6. Basics of Handle Graphics
                                                                                                                                                • ☰ 13. Working with Scripts and Live Scripts
                                                                                                                                                  • ☰ 13.1. Creating and Running Script Files
                                                                                                                                                    • ☰ 13.2. Sectioning Code and Running Sections
                                                                                                                                                      • ☰ 13.3. Live Scripts and Rich Text
                                                                                                                                                        • ☰ 13.4. Adding Equations, Images, and Outputs
                                                                                                                                                          • ☰ 13.5. Sharing and Exporting Live Scripts
                                                                                                                                                          • ☰ 14. Debugging and Code Quality
                                                                                                                                                            • ☰ 14.1. Finding and Fixing Syntax Errors
                                                                                                                                                              • ☰ 14.2. Setting Breakpoints and Stepping Through Code
                                                                                                                                                                • ☰ 14.3. Inspecting Variable Values During Execution
                                                                                                                                                                  • ☰ 14.4. Using the Editor Debugging Tools
                                                                                                                                                                    • ☰ 14.5. Using Code Analyzer and Warnings
                                                                                                                                                                      • ☰ 14.6. Writing Clean and Maintainable MATLAB Code
                                                                                                                                                                      • ☰ 15. Basic Linear Algebra with MATLAB
                                                                                                                                                                        • ☰ 15.1. Vectors and Norms
                                                                                                                                                                          • ☰ 15.2. Matrix Addition and Multiplication
                                                                                                                                                                            • ☰ 15.3. Solving Linear Systems with Backslash
                                                                                                                                                                              • ☰ 15.4. Inverses, Determinants, and Rank
                                                                                                                                                                                • ☰ 15.5. Eigenvalues and Eigenvectors
                                                                                                                                                                                  • ☰ 15.6. Using Linear Algebra Functions Safely
                                                                                                                                                                                  • ☰ 16. Data Analysis and Statistics Fundamentals
                                                                                                                                                                                    • ☰ 16.1. Descriptive Statistics and Summary Measures
                                                                                                                                                                                      • ☰ 16.2. Sorting, Filtering, and Grouping Data
                                                                                                                                                                                        • ☰ 16.3. Basic Correlation and Regression
                                                                                                                                                                                          • ☰ 16.4. Simple Data Cleaning Techniques
                                                                                                                                                                                            • ☰ 16.5. Basic Time Series Handling
                                                                                                                                                                                            • ☰ 17. Working with Time and Dates
                                                                                                                                                                                              • ☰ 17.1. Representing Dates and Times
                                                                                                                                                                                                • ☰ 17.2. Creating and Formatting datetime Arrays
                                                                                                                                                                                                  • ☰ 17.3. Date Calculations and Differences
                                                                                                                                                                                                    • ☰ 17.4. Plotting Data over Time
                                                                                                                                                                                                    • ☰ 18. Introduction to Signal and Image Handling
                                                                                                                                                                                                      • ☰ 18.1. Basic Signal Representation in MATLAB
                                                                                                                                                                                                        • ☰ 18.2. Simple Filtering and Transformations
                                                                                                                                                                                                          • ☰ 18.3. Reading, Displaying, and Writing Images
                                                                                                                                                                                                            • ☰ 18.4. Basic Image Transformations
                                                                                                                                                                                                            • ☰ 19. Automation and Scripting Tasks
                                                                                                                                                                                                              • ☰ 19.1. Batch Processing of Files
                                                                                                                                                                                                                • ☰ 19.2. Writing Reusable Utility Scripts
                                                                                                                                                                                                                  • ☰ 19.3. Using Relative Paths and the MATLAB Path
                                                                                                                                                                                                                    • ☰ 19.4. Simple User Interaction with input and disp
                                                                                                                                                                                                                    • ☰ 20. Introduction to Toolboxes
                                                                                                                                                                                                                      • ☰ 20.1. What Are Toolboxes and How to Use Them
                                                                                                                                                                                                                        • ☰ 20.2. Exploring Installed Toolboxes
                                                                                                                                                                                                                          • ☰ 20.3. Finding Functions in Toolboxes
                                                                                                                                                                                                                            • ☰ 20.4. Add-Ons and MATLAB File Exchange
                                                                                                                                                                                                                            • ☰ 21. Best Practices and Next Steps
                                                                                                                                                                                                                              • ☰ 21.1. Organizing Projects and Folders
                                                                                                                                                                                                                                • ☰ 21.2. Version Control Basics with MATLAB
                                                                                                                                                                                                                                  • ☰ 21.3. Performance Tips for Beginners
                                                                                                                                                                                                                                    • ☰ 21.4. Learning Resources and Documentation Path
                                                                                                                                                                                                                                      • ☰ 21.5. Suggested Practice Projects for Beginners