DWG in the Browser? Meet MLightCAD CAD Viewer

Mlight Lee — Wed, 07 Oct 2026 11:06:54 +0000

If you have ever worked with CAD files on the web, you probably know the problem.

A .dwg or .dxf file is not just another document format. Unlike images or PDFs, CAD drawings are interactive engineering data containing layers, blocks, dimensions, text, geometry, and many other entities.

Traditionally, viewing these files means installing a desktop CAD application or uploading the file to a server for processing.

MLightCAD CAD Viewer takes a different approach: open and interact with DWG/DXF files directly in the browser.

No CAD application.
No backend server.
No file upload required.

The project is open source and available on GitHub under the MIT license.

What is MLightCAD CAD Viewer?

MLightCAD CAD Viewer is a web-based DWG/DXF viewer and editor designed to bring CAD workflows into the browser.

It can load, parse, render, and interact with CAD drawings entirely on the client side. This makes it possible to build CAD-related web applications without maintaining a dedicated CAD processing server.

It is also designed to be more than just an online file viewer.

You can use it as:

A standalone DWG/DXF viewer
A Vue 3 component inside your own application
A CAD visualization SDK
A component embedded into another website or application
An offline CAD viewer
A foundation for building browser-based CAD applications
A command-line workflow for processing CAD drawings
A portable single-file CAD review application

The goal is simple:

Make CAD data as accessible on the web as other digital content.

Open a DWG or DXF Directly in Your Browser

The most important feature is also the simplest one.

Drop a DWG or DXF file into the viewer and start working with it.

There is no need to first convert the drawing into SVG, PDF, PNG, or another intermediate format. The browser handles the CAD data directly. This is particularly useful when building applications where CAD drawings are just one part of a larger workflow.

For example, imagine a construction management application where users need to inspect floor plans, or a manufacturing platform where users need to preview engineering drawings associated with a part.

Instead of asking users to download the drawing and open it with another application, the drawing can simply become part of the web application.

A Familiar CAD Experience

MLightCAD CAD Viewer is not designed to be just a canvas displaying some lines. It provides many of the interactions that CAD users expect.

Navigation

Users can:

Zoom in and out
Pan around the drawing
Zoom to extents
Select drawing entities
Navigate large drawings interactively

The interaction model is designed to feel familiar to people who already work with CAD software. It also supports touch interaction, making the viewer suitable for tablets and mobile devices.

Layer Management

CAD drawings often contain hundreds of layers.

The viewer provides a layer management interface that allows users to:

Show or hide layers
Inspect layer information
Focus on specific parts of a drawing
Work with drawings containing complex layer structures

This makes it much more useful for real engineering drawings than a simple geometry renderer.

Measurement

The viewer also provides measurement capabilities for reviewing drawings. For example, users can measure distances directly on the drawing without exporting it to another application.

The goal is not to replace a full desktop CAD system, but to provide the essential tools needed for viewing, reviewing, inspecting, and sharing drawings on the web.

CAD-Style Command Line

For users who are comfortable with AutoCAD-style workflows, CAD Viewer also includes a command-line interface. This provides an interesting bridge between traditional CAD applications and modern web applications. Instead of treating CAD as an unfamiliar web canvas, the project brings some familiar CAD concepts into the browser.

Designed for Large CAD Drawings

One of the biggest challenges in browser-based CAD is performance. A CAD drawing can contain tens of thousands, hundreds of thousands, or even millions of graphical elements. Rendering every entity independently would quickly become expensive in a WebGL environment.

MLightCAD CAD Viewer therefore puts significant effort into efficient rendering and geometry batching. The result is a viewer designed to remain interactive even when working with relatively large and complex drawings.

This matters because a browser-based CAD viewer is only useful if it remains responsive when users open the drawings they actually use in production.

Performance is therefore treated as a core part of the architecture rather than an optimization added later.

Privacy by Design

One of the most interesting consequences of browser-side CAD processing is privacy. When a user opens a drawing locally, the file does not have to be uploaded to a remote CAD processing service. This is important for engineering organizations. CAD drawings can contain:

Product designs
Manufacturing information
Building layouts
Mechanical details
Customer information
Proprietary engineering data

For many organizations, sending such files to an external server simply to generate a preview is undesirable or even impossible. With browser-side processing, applications can keep the drawing on the user's machine.

This also makes CAD Viewer suitable for environments where network access is limited or completely unavailable.

From Online Viewer to Offline CAD Application

There is another interesting capability that comes from this architecture.

A drawing can be exported into a single self-contained HTML file.

The resulting file contains the drawing data together with the viewer runtime. You can send that HTML file to someone else. They can open it in a modern browser without installing CAD software, running a server, or connecting to your application.

Want to try it yourself? You can use the DWG to HTML Converter to convert a DWG file into a self-contained HTML file directly in your browser.

The recipient can still:

Open the drawing
Pan and zoom
Control layers
Inspect the drawing
Measure distances

This turns a CAD drawing into a portable web document. Think about sending a CAD drawing to a customer.

Instead of saying:

"Please install this CAD viewer."

you can simply send:

"Open this HTML file."

This can also be useful for:

Design reviews
Project archives
Documentation
Customer communication
Offline environments
Air-gapped environments
Long-term drawing archives

Embed CAD into Your Website with One Line of Code

You don't even need to build a CAD application from scratch. MLightCAD CAD Viewer can also be embedded directly into an existing website or web application. In many cases, you can add a DWG/DXF viewer with just a single line of HTML code.

For example, an application can simply embed the viewer as an iframe:

<iframe
  src="https://mlightcad.com/iframe-plugin.html?url=YOUR_DWG_OR_DXF_URL"
  width="100%"
  height="600"
  frameborder="0">
</iframe>

This makes it possible to add CAD viewing capabilities to websites, documentation systems, project management platforms, CMSs, customer portals, or internal engineering applications without implementing a CAD rendering engine yourself.

You can try the one-line DWG/DXF embedding experience here: MLightCAD IFrame Plugin.

The idea is simple: your application provides the CAD file, and MLightCAD provides the CAD viewing experience. This makes CAD content much easier to integrate into the web.

CAD on Any Website

Another important aspect of CAD Viewer is that it does not have to be used as a standalone application.

It can be integrated into an existing web application.

For example, you could have:

Your Application
       │
       ├── Project Management
       ├── Documents
       ├── BOM
       ├── Engineering Data
       │
       └── MLightCAD CAD Viewer
                │
                ├── DWG
                └── DXF

This makes CAD drawings another type of content inside your application.

A project management system can display its engineering drawings.
A document management system can preview DWG files.
A manufacturing platform can display drawings next to product information.
A collaboration system can provide drawing review without requiring users to leave the application.

And because the viewer runs in the browser, the integration can remain entirely web-based.

Data Sources Are Not Limited to Local Files

The viewer can also be integrated with different data sources.

A DWG/DXF file does not necessarily have to come from a local file picker.

It can come from a web application, cloud storage, document management system, or another data source.

This makes it possible to build integrations such as:

CAD files stored in OneDrive
CAD files stored in Google Drive
CAD drawings inside a document management system
CAD previews inside collaboration platforms
CAD drawings inside CMS systems
CAD files served from your own API

For example, you can try opening DWG/DXF drawings directly from your OneDrive using the MLightCAD OneDrive integration.

The viewer becomes the CAD rendering layer, while your application decides where the CAD data comes from.

This separation is important because it means you don't need to build a CAD engine every time you want to add CAD support to a product.

Build Your Own CAD Application

For developers, CAD Viewer can be used at different levels.

If you simply need a ready-to-use viewer, you can use the complete application.
If you are building a Vue 3 application, you can integrate the CAD viewer as a component.
And if you want more control, the project also provides lower-level building blocks for creating your own CAD experiences.

This opens the door to applications such as:

Online CAD viewers
CAD review systems
Engineering document platforms
Construction management applications
Manufacturing platforms
CAD collaboration tools
CAD asset management systems
Digital twins
GIS/CAD applications
AI-assisted CAD tools

The important idea is that the viewer does not have to be the final product.

It can be the CAD engine inside another product.

A Web-Native CAD Ecosystem

This is perhaps the larger vision behind MLightCAD CAD Viewer.

The project is not trying to recreate the entire desktop CAD world inside a browser overnight.

Instead, it provides a foundation for bringing CAD data into the web.

The architecture allows different pieces of the ecosystem to evolve independently:

CAD data → CAD model → rendering → interaction → application

That means developers can build specialized experiences on top of the same CAD foundation.

One application might focus on document preview.

Another might focus on engineering review.

Another might focus on measurement.

Another might integrate CAD with GIS.

Another might use CAD data as part of an AI workflow.

The CAD viewer becomes infrastructure rather than just an application.

Command Line and Automation

CAD Viewer is also useful outside the browser UI.

The project provides command-line tooling for CAD-related workflows.

For example, CAD drawings can be processed in batches and converted into images or other web-friendly representations.

This can be useful for:

Generating previews
Creating thumbnails
Building document indexes
Preparing datasets
Automating CAD workflows
Preparing data for AI/ML applications

This is particularly interesting as CAD increasingly becomes part of automated and AI-driven workflows.

Why Browser-Based CAD Matters

The web has changed how we work with almost every other type of content.

We can open documents in a browser.

We can edit images in a browser.

We can collaborate on spreadsheets in a browser.

We can review videos in a browser.

But CAD has remained heavily tied to desktop software.

There are good reasons for this. CAD files are complicated, and high-performance rendering is difficult.

But modern browsers now provide technologies such as WebAssembly, WebGL, Web Workers, and increasingly powerful JavaScript runtimes.

These technologies make a different model possible.

Instead of:

CAD File
   ↓
Upload to Server
   ↓
CAD Processing
   ↓
Server Rendering
   ↓
Browser

you can have:

CAD File
   ↓
Browser
   ├── Parse
   ├── Process
   ├── Render
   └── Interact

That changes the architecture of web-based CAD applications.

It can reduce server infrastructure, improve privacy, support offline scenarios, and make CAD much easier to embed into existing web products.

Open Source

MLightCAD CAD Viewer is open source and released under the MIT license.

The project is available on GitHub and welcomes developers who want to experiment with browser-based CAD.

If you are building something around DWG/DXF, you don't necessarily need to start by implementing a CAD engine from scratch.

You can start with a working browser-based CAD foundation and build your own application around it.

What's Next?

The current viewer is only one step toward a broader vision.

The direction is to gradually move from:

CAD Viewer → CAD Review → CAD Editing → CAD Applications

and eventually connect CAD with other parts of the modern software ecosystem.

That includes cloud storage, document management, collaboration, AI, GIS, mobile applications, and offline workflows.

The interesting part is not simply putting AutoCAD drawings into a browser.

It is making CAD data a first-class citizen of the web.

Try It

If you work with DWG/DXF files or are building a web application that needs CAD support, give MLightCAD CAD Viewer a try.

You can explore the source code, run the demo, or integrate the viewer into your own application.

GitHub: mlightcad/cad-viewer

If you're building something interesting with it, I'd love to hear about it.

And if you have ideas, feature requests, or integration scenarios, feel free to open an issue or start a discussion.

The future of CAD may not be another desktop application.

It might be the browser.

DEV Community: Mlight Lee