You can view PDFs, Office files, CAD drawings, email, and images in the browser without installing legacy plugins. For Windows-based .NET applications, Doconut Viewer provides backend document processing while users remain inside the business application.

Modern plugin-free document viewing in a Windows browser application

In the next sections we’ll explore why removing legacy plugins matters, outline an ASP.NET Core integration workflow, and discuss drag-and-drop uploads and Blazor integration without relying on unverified SDK code.

Zero Plugins: Why They’re a Game‑Changer for .NET Web Apps

Eliminate the “install‑first” friction

Traditional viewers cling to ActiveX, Java or Flash. Those demand permission, trigger security alerts and break on modern browsers. Doconut sidesteps that by rendering on the server and sending the browser ordinary HTML and images — nothing to install on the client, no prompts, no IT tickets.

That distinction matters for the rest of this article, so it is worth stating plainly: the parsing and rasterising happen on your server, not in the user's browser. Plugin-free means the client needs nothing; it does not mean the work has moved into JavaScript.

Keep the browser sandbox intact

Since no external plugin loads, the browser's sandbox stays untouched. Better still, the user's machine never receives the source document at all — it receives rendered pages — so a malicious PDF has nothing to act on at that end.

What this does not do is remove the attack surface; it moves it to your server, where a parser is processing untrusted input. Run it with least privilege, keep it patched, and validate uploads. Transport security, encryption at rest and retention are your application's to implement — the SDK does not ship them.

Future-proof across browsers and devices

Because the browser only has to display standard HTML and images, there is very little for a browser update to break. Chrome, Edge, Safari or a mobile WebView all behave the same, with no "plugin missing" warnings and no version-specific workarounds — and a low-powered device is not a disadvantage, since it is not doing the rendering.

Embedding Doconut App’s Plugin‑Free Viewer in ASP.NET Core

To integrate the viewer, generate a short-lived, signed URL for the document on the server and pass it to the client. The server renders the document and streams pages over HTTPS into a container element on the page.

Server‑side workflow (conceptual)

Receive a request for a document.
Retrieve the file from your storage (SQL, Blob, etc.).
Create a time‑limited, signed URL that points to the encrypted file.
Return that URL to the Razor view.

Razor view (conceptual)

Keep the view responsible for layout and authorized viewer state, while the server retrieves and processes the document. Use only the client resources and initialization sequence documented for the installed Doconut version.

When the page loads, the client requests the document by its signed URL and displays the pages the server returns. No ActiveX, Java or Flash.

Why this matters

Zero plugins: the client needs a browser and nothing else.
The source file never reaches the user: they receive rendered pages, so there is no local copy to forward, cache or leak.
Security is yours to build: the URL being short-lived and signed is code you write. Nothing about the viewer enforces it for you, so make it part of the design rather than an assumption.
Paging: pages are delivered as needed rather than all at once, which is what keeps a long PDF or a dense drawing usable.

Rendering Supported Formats Without Plugins

The SDK's engine handles 75 file extensions across 18 families — PDF, DOCX, XLSX, PPTX, DWG, DXF, PSD, VSDX, MPP, EML, MSG, EPUB, TIFF, PNG, JPEG and the rest, including DICOM through its separately licensed plugin. The free viewers at doconut.app accept 73 of those: everything except .dcm and .ima.

The engine identifies the file by its contents rather than its extension, which matters more than it sounds — a great many files named .xls are actually HTML tables or CSV.

One caveat on fidelity, since "pixel-perfect" is a promise no renderer can keep: documents that reference resources they do not contain will differ from what their author saw. Fonts that were never embedded get substituted, and a DWG's external references are not inside the DWG.

Drag‑and‑Drop Upload with Instant, Plugin‑Free Rendering

Enterprises want users to preview files in place. You can add a drag-and-drop zone that uploads a document, generates a signed view URL and displays the result with no plugin on the client. The whole cycle stays inside your .NET backend — which is what lets you keep audit trails, since the logging is yours to write.

Client‑side flow (conceptual)

User drags a file onto a designated area.
JavaScript sends the file to an ASP.NET Core endpoint.
The endpoint stores the file securely and returns a signed view URL.
The page injects a <div> with data‑doc‑url pointing to that URL.
Doconut App’s script renders the document instantly.

Rendering happens on your server, so plan for it: this is where the CPU and memory go, and it scales with concurrent viewers rather than with users. Check where the SDK writes temporary render output and make sure something cleans it up — orphaned files in a temp directory are the most commonly overlooked part of an integration.

Consistent Viewing in Windows-Based Workflows

A browser viewer can provide a consistent entry point for users of an internal Windows application without requiring separate desktop document programs. Teams should test supported browsers, screen sizes, input methods, document complexity, and accessibility requirements rather than assuming identical behavior in every environment.

Extending the Viewer with Blazor – Keep Everything Inside Your .NET Ecosystem

If your team prefers a component-centric approach, you can wrap the viewer's client-side script in a Blazor component, under either hosting model. That keeps the integration inside the .NET world. Note that the hosting model only affects where your UI code runs — document rendering stays on the server either way.

Blazor component outline (conceptual)

Inject a service that can generate a secure view URL for a given file ID.
On initialization, request the URL from the service.
After the component renders, initialize the viewer using the supported integration API for the installed Doconut version.

The Blazor component can coordinate viewer state while the backend remains responsible for document access and processing. This keeps the workflow inside the .NET application without publishing assumptions about a global JavaScript API.

Key Takeaways

Zero plugins remove installation friction, security warnings and compatibility headaches.
The SDK renders 75 extensions — PDF, Office, CAD, email and images — on the server, not in the browser.
Integration: generate a signed view URL server-side and display the returned pages in a container.
Drag-and-drop upload plus in-place preview keeps users in the flow.
It behaves the same on desktop, tablet and mobile, because the browser only displays standard output.
Blazor developers can wrap the viewer in a .NET component.
Security is architectural, not a feature list: the source file never reaches the client, and the document never leaves your infrastructure. Encryption at rest, signed-URL expiry and audit logging are yours to implement — and Doconut holds no ISO 27001, SOC 2 or HIPAA certification to lean on.

Common Questions

Q: Do I need to install anything on the client machines?
A: No. The Doconut App viewer runs entirely in the browser using HTML5 and JavaScript. Users only need a modern browser—no ActiveX, Java, or Flash installations are required.

Q: How does it handle large files?
A: Pages are rendered and delivered as they are needed, so a reader can jump to a page without waiting for the whole document. Note that this is your server doing the work — test with your heaviest real files to size it. On the free site at doconut.app the ceiling is ours and it is per format: 25 MB for a PDF, 10 MB for a CAD drawing.

Get Started with Doconut App Today

Ready to eliminate legacy plugins from your Windows-based .NET application? Evaluate the Doconut SDK with the browsers, document formats, and workloads used by your organization.