Importing and Exporting in Stud.io: LDraw, BrickLink, and File Formats Explained

If you have been following this Stud.io tutorial series, you already know how to build, render, and create instructions inside the application. But there is an entire dimension of Stud.io that most builders never explore — its ability to communicate with other software, other platforms, and other builders through file formats. Understanding imports and exports is not just a technical exercise. It is the difference between being locked into a single tool and having a workflow that spans the entire LEGO digital ecosystem.

Consider the practical scenarios. You find a brilliant LDraw model on an online repository and want to modify it in Stud.io. You finish a MOC and need to generate a BrickLink wanted list so you can actually buy the parts. You want to create an animation using your Stud.io model in Blender. You have an old LEGO Digital Designer file from 2015 that you want to resurrect. Every one of these situations requires understanding how Stud.io handles file formats — what it can read, what it can write, and where the conversion quirks live.

This guide covers every import and export pathway in Stud.io. We will walk through the native .io format, LDraw compatibility, LDD migration, parts list exports, image rendering, 3D exports for animation, a complete file compatibility reference chart, batch operations for managing large projects, and backup strategies to protect your work. Whether you are a solo builder managing personal files or a community contributor sharing models with thousands, this is the reference you need.

Every Stud.io project saves as an .io file. This is a proprietary binary format that stores everything about your model — part geometry, color assignments, submodel hierarchy, step groupings, building instruction sequences, flexible part positions, and rendering settings. It is the richest format available because it was designed specifically for Stud.io and captures every feature the application offers. When you save a project, this is what you get by default, and it is the format you should use for any model you plan to continue editing.

The .io format has several advantages over open formats like LDraw. It preserves Stud.io-specific features that have no equivalent in other systems — things like the instruction builder step layout, custom page formatting, and Photo Realistic rendering presets. If you export to LDraw and re-import, you will lose these settings. The .io file also tends to be smaller than equivalent LDraw files because it uses compressed binary storage rather than plain text. For a complex model with thousands of parts, this size difference can be significant.

The main limitation of the .io format is that it is Stud.io-only. No other application can open .io files directly. This means sharing models with builders who use LDraw-based tools (LeoCAD, LDCad, MLCad) requires an export step. It also means your models are tied to BrickLink's continued development of Stud.io — a dependency worth considering for long-term archival. The practical solution is to keep your working files in .io format for maximum fidelity and export to LDraw whenever you want to share or archive a model in an open format.

LDraw is the grandfather of LEGO digital building formats. Created in the late 1990s, it is an open standard that defines LEGO parts as collections of geometric primitives in plain text files. Individual models use the .ldr extension. Multi-part documents that contain submodels use .mpd. Stud.io can import both, and this capability is one of its most important features because the LDraw community has produced tens of thousands of models over the past two decades.

To import an LDraw file, go to File > Import > LDraw File and select your .ldr or .mpd file. Stud.io will parse the file and convert each LDraw part reference to its internal part library equivalent. In most cases, this conversion is seamless — Stud.io's part library is built on BrickLink's database, which maps cleanly to LDraw part numbers. However, there are edge cases. Some older LDraw parts use unofficial or custom geometry that Stud.io does not recognize. When this happens, Stud.io will either substitute a similar part, display a placeholder, or skip the part entirely with a warning in the import log.

Color mapping is another area where minor discrepancies can appear. LDraw uses its own color numbering system (LDraw Color Codes), while Stud.io uses BrickLink color IDs. The two systems overlap heavily but are not identical. Stud.io handles the conversion automatically, but occasionally a color will shift slightly — a dark bluish gray might import as a slightly different shade, or a metallic color might lose its finish designation. After importing, always do a visual scan of your model to catch any color mapping issues. If you find an LDraw model you want to modify and eventually order parts for, import it into Stud.io, verify the colors, and then use the BrickLink wanted list export to generate an accurate shopping list.

LEGO Digital Designer was LEGO Group's official digital building tool from 2004 until its discontinuation in 2022. During its nearly two-decade run, millions of builders created models in LDD, and those .lxf files still exist on hard drives and community repositories worldwide. Stud.io can import .lxf files, making it the natural migration path for anyone moving from the discontinued LDD to an actively supported tool.

The import process is straightforward: File > Import > LDD File. Stud.io reads the .lxf container (which is technically a renamed ZIP archive containing XML model data and embedded assets) and converts each part and connection to its internal format. The conversion quality is generally excellent for standard bricks, plates, and slopes. LDD and Stud.io share the same underlying part design data from LEGO Group, so the geometric translation is nearly perfect for official elements.

Where LDD imports can struggle is with LDD-specific features that have no Stud.io equivalent. LDD's "hinge assist" system, which automatically positioned hinged parts at specific angles, does not translate directly. Flex elements like hoses and chains may need manual adjustment after import. LDD's building guide (its version of building instructions) does not transfer — you will need to recreate your step sequences using Stud.io's Instruction Builder. Despite these limitations, LDD import is reliable enough that you should feel confident converting your entire LDD library to Stud.io. The alternative — keeping LDD installed on increasingly incompatible operating systems — is not a viable long-term strategy.

Exporting your Stud.io models to LDraw format is essential for sharing with the broader digital LEGO community. Not every builder uses Stud.io, and many community platforms, renderers, and tools are built around the LDraw ecosystem. When you publish a model online, providing an LDraw export alongside your .io file maximizes the audience that can open and work with your design.

To export, go to File > Export As > LDraw File. You can choose between .ldr (single model) and .mpd (multi-part document). If your model uses submodels — and most complex MOCs should — choose .mpd. This packages everything into a single file rather than scattering submodels across multiple .ldr files that need to live in the same directory. The .mpd format is self-contained and portable, which makes it the better choice for sharing.

During export, Stud.io converts its internal part references to LDraw part numbers and maps BrickLink colors back to LDraw color codes. The conversion is generally clean, but Stud.io-specific features are lost. Instruction builder layouts, custom rendering settings, and any part positions that rely on Stud.io's enhanced connection system will be simplified or dropped. Flexible parts like pneumatic tubes and string elements may export with approximate positions. After exporting, it is good practice to open the resulting LDraw file in a viewer like LDView or LeoCAD to verify that everything looks correct before you share it. If you are building a MOC you plan to submit to LEGO Ideas, having a clean LDraw export available demonstrates professionalism and makes your design accessible to the review team.

For many builders, the most practically valuable export from Stud.io is not a 3D model file — it is a parts list. The entire point of designing digitally is to eventually build physically, and that means buying parts. Stud.io integrates directly with BrickLink, the world's largest marketplace for LEGO parts, and its parts list export is the bridge between your digital design and your physical shopping cart.

The primary export format is BrickLink XML. Go to File > Export As > BrickLink Wanted List XML. This generates an XML file structured exactly as BrickLink's wanted list import expects it. Each part is identified by BrickLink part number and color ID, with quantities aggregated across your entire model. You can then log into BrickLink, go to your wanted list page, and upload the XML file directly. BrickLink will parse it, create or update a wanted list, and you can immediately start shopping for parts across hundreds of sellers worldwide. For a complete walkthrough of the wanted list buying process, see the BrickLink Wanted Lists Guide.

Stud.io also supports CSV export for parts lists. This is a simpler, spreadsheet-friendly format that lists part number, color, quantity, and description in comma-separated columns. CSV exports are useful for inventory management, cost estimation in external spreadsheets, and sharing parts lists with people who do not use BrickLink. You can open a CSV parts list in Excel or Google Sheets, add price columns, calculate totals, and manage your sourcing across multiple vendors. Some builders maintain a master spreadsheet of their entire parts inventory and use CSV exports from Stud.io to reconcile what they need against what they already own. This is particularly powerful when you are designing multiple MOCs and want to minimize duplicate purchases.

Stud.io offers two tiers of image export. The first is a simple screenshot capture using File > Export As > Image, which saves the current viewport as a PNG file. This is fast and useful for quick reference shots, work-in-progress shares on social media, or documentation images for your first MOC project. You can control the resolution, background color (including transparent backgrounds), and camera angle before capturing. For most sharing purposes — forum posts, Discord messages, personal records — this is all you need.

The second tier is Photo Realistic rendering, accessible through the Render tab. This uses a ray-tracing engine to produce photorealistic images of your model with accurate lighting, material reflections, subsurface scattering on translucent elements, and ambient occlusion for depth. Rendered images export as high-resolution PNG files and are suitable for portfolio presentation, LEGO Ideas submissions, and print-quality documentation. The rendering process is computationally intensive — a complex model at full resolution can take several minutes to render — but the results are dramatically better than viewport screenshots.

When exporting images for specific purposes, consider your output requirements. For social media, 1920x1080 or 1080x1080 (square) at 72 DPI is standard. For print, render at a minimum of 300 DPI. For LEGO Ideas submissions, use high resolution with a clean, neutral background — white or light gray works best. Stud.io's rendering presets include several background options, and you can also render with transparency for compositing in image editing software. If you are building instructions, the Instruction Builder has its own image export pipeline optimized for step-by-step clarity rather than photorealism.

One of Stud.io's most underused features is its ability to export 3D models in formats compatible with professional animation and rendering software. The primary 3D export format is Collada (.dae), an open interchange standard supported by Blender, Cinema 4D, Maya, 3ds Max, and virtually every other 3D application. This capability transforms Stud.io from a building tool into a content creation pipeline.

To export a Collada file, go to File > Export As > Collada. The resulting .dae file contains the full geometry of your model with materials and colors assigned. When you open this file in Blender or another 3D application, each LEGO element appears as a separate mesh object with its color preserved. From there, you can add professional lighting, create camera animations, apply physics simulations (imagine your MOC exploding into individual bricks in slow motion), and render at cinematic quality. The LEGO animation community on YouTube has produced stunning work using exactly this pipeline — Stud.io for design, Collada export, Blender for animation and rendering.

There are important considerations for 3D export. Collada files from Stud.io can be very large because every element is exported as full geometry rather than instanced references. A 5,000-piece model might produce a .dae file of several hundred megabytes. Blender can handle this, but you may need to optimize the geometry (merge duplicates, reduce polygon counts) for smooth animation performance. Material mapping also needs attention — Stud.io exports basic colors but not the nuanced material properties (metallic sheen, pearl finish, rubber texture) that make LEGO elements look convincing in photorealistic renders. You will need to set up proper LEGO material shaders in your 3D application manually. Despite these workflow steps, the Collada export makes Stud.io a legitimate front end for professional LEGO animation.

With so many formats in play, it helps to have a single reference for what goes where. The table below summarizes every format Stud.io can read and write, along with compatibility notes for common workflows.

The key takeaway from this chart is that Stud.io is an excellent importer but a selective exporter. It can read the two most important legacy formats (LDraw and LDD) but only writes to LDraw for 3D model interchange. For parts data, it exports to BrickLink XML and CSV. For visual output, PNG. For 3D animation pipelines, Collada. This coverage handles the vast majority of real-world workflows, but it does mean that round-tripping — exporting from Stud.io and re-importing into Stud.io — only works losslessly with the native .io format. Any other format will lose some degree of Stud.io-specific data.

Once you move beyond single models and start managing a library of designs — which happens faster than most builders expect — batch operations become essential. Stud.io does not have a built-in batch processing system, but there are practical strategies for managing multiple models efficiently.

The first strategy is consistent file organization. Create a folder hierarchy that mirrors your building categories: MOCs by theme, work-in-progress designs, completed and archived models, shared community files. Within each folder, use a naming convention that includes the model name, version number, and date. Something like castle-gatehouse_v3_2026-03-10.io is far more useful six months from now than model1.io. When you need to generate parts lists for multiple models, you can open each one in sequence and export the BrickLink XML, then combine the XML files in a text editor to create a consolidated wanted list for a single BrickLink order.

For builders managing really large projects — collaborative builds, convention displays, entire LEGO cities — the submodel system within Stud.io is your batch management tool. Design each section of the larger project as a separate submodel within a single .io file. This lets you work on individual sections without loading the entire project, export submodel-specific parts lists, and generate section-by-section building instructions through the Instruction Builder. When you need to share specific sections with collaborators, export just those submodels as LDraw files. The parent .io file keeps everything connected while the submodel architecture keeps individual work sessions manageable.

Digital files are fragile. Hard drives fail, cloud services shut down, and proprietary formats become unreadable when the software that created them is discontinued — ask any LEGO Digital Designer user. A robust backup strategy for your Stud.io models should address three risks: hardware failure, software obsolescence, and data corruption.

For hardware failure, the solution is redundancy. Keep your .io files in at least two locations — a local drive and a cloud service (Google Drive, Dropbox, iCloud, or similar). Version your files so that a corruption event does not overwrite your only copy. Many builders use a simple date-based versioning system where each save session creates a new file rather than overwriting the previous one. Storage is cheap. Lost designs are not.

For software obsolescence, maintain LDraw exports of every completed model. The .mpd format is an open, plain-text standard that has been readable by dozens of applications for over twenty-five years. Even if Stud.io ceases development tomorrow, your LDraw files will remain usable indefinitely. Think of LDraw as your archival format and .io as your working format. Every time you finish a model or reach a significant milestone, export an .mpd copy alongside your .io save. For an extra layer of insurance, export a CSV parts list as well. Even if every 3D file becomes unreadable, a parts list lets you rebuild from scratch.

Finally, render images of your finished models from several angles. Images are the most durable digital format — a PNG from 2006 opens as easily today as it did then. A set of high-quality renders serves as visual documentation that outlasts any 3D format. Combined with a parts list and LDraw archive, you have a three-layer backup system that protects against virtually any failure scenario. Your first MOC might not feel precious now, but five years from now you will be glad you kept it safe.

A model only exists as long as the file that describes it. Back up your work. Future you will be grateful.

Stud.io's import and export system is not glamorous, but it is the infrastructure that connects your creative work to the rest of the LEGO digital world. Master these file formats and you will never be locked into a single tool, never struggle to share a design, and never lose a model to a preventable failure. The Builds hub has more inspiration for your next project, the Reviews section covers the latest sets, and the Parts Lab goes deep on individual elements. And when you are ready to turn a digital design into a real build, the LEGO Shop has everything you need to make it happen.