OHIF Viewers: a browser DICOM viewer you reshape with extensions, not forks
OHIF zero-footprint DICOM viewer and oncology specific Lesion Tracker, plus shared extension packages
At a glance
- What is it?
- OHIF Viewers is a TypeScript monorepo that builds a zero-footprint DICOMweb viewer for radiology and oncology teams, where every core feature is delivered through an extension system. Adopting it means owning a TypeScript codebase and a pnpm toolchain, not downloading a binary.
- Who is it for?
- Imaging teams that already run a DICOMweb archive and want a viewer they can change without maintaining a fork should build on OHIF Viewers, which is the case the extension system was designed around. Teams that need a fixed diagnostic workstation for one modality, or that cannot put a Node 24 and pnpm 12 toolchain in front of their deployment pipeline, should buy that instead.
- Can I use it commercially?
- Yes. MIT is a permissive licence: you can use, modify and sell software built on it, as long as you keep its copyright and licence notices.
- Is it still maintained?
- Yes. The repository last received commits 1 day ago.
- What is it written in?
- Mainly TypeScript, according to GitHub's language statistics.
Answers come from the project's GitHub data, last synced on November 21, 2026, and from our analysis. They are not legal advice.
Star history
- OHIF/Viewers4,416 ★ · +71
| Repository | 2026-09-23 | 2026-11-21 |
|---|---|---|
| OHIF/Viewers | 4.3k | 4.4k |
71 Stars in the last 59 days, measured from the daily GitHub snapshot. Compare with other projects
Editorial analysis
Every core feature is an extension, which is the whole architecture
The decision that shapes everything else in this repository is that no core feature is privileged. Every core feature is built on the project's own extension system, and the directory layout backs that up: extensions/, modes/, platform/ and specs/ sit side by side at the repository root, alongside aliases.config.js and version.json.
For a radiology department that means the difference between configuring and forking. If your protocol needs a context specific toolbar and side panel content, or user access control, you add a package rather than patching a fork you now have to rebase on every upstream push. The repository description also names an oncology specific Lesion Tracker and shared extension packages, which tells you the lesion tracking work happens in the same package graph as the viewer itself.
That choice has a cost. A build is a pnpm workspace operation over many packages, not a single install. The root manifest names packageManager [email protected] and requires node >=24 with pnpm >=12, and its build entry is a workspace filter rather than a local call:
pnpm --filter @ohif/app run build:viewerThat filter is the release artifact. Everything you configure ends up in the static output of one app package.
DICOMweb plus hanging protocols set the ceiling on what you can display
Rendering scope is decided by the archive and by the hanging protocol, not by the viewer alone. Support for image archives that speak DICOMweb works out of the box, and the demo table links each capability to a specific StudyInstanceUID: labelmap segmentations, fusion with custom hanging protocols, volume rendering through hangingprotocolId=mprAnd3DVolumeViewport, RT STRUCT, 4D dynamic volume, PDF, video and slide microscopy.
Read that table as a contract with the archive. Each demo is a live URL, and each URL depends on a study the public server already holds.
For a team evaluating the viewer, the useful question is not which modalities OHIF renders. It is which of those modalities your PACS or archive layer exposes over DICOMweb today. The project also offers OpenID Connect and internationalization, which is another reason to read the feature list before committing.
The README tells you to install Yarn, and package.json refuses anything but pnpm
This is the first thing that trips up a new contributor. The requirements list in the README names Yarn 1.20.0+, while the branching notes show packages published to npm under beta numbers. Meanwhile the root manifest pins [email protected], sets engines node >=24 and pnpm >=12, and the repository ships pnpm-lock.yaml and pnpm-workspace.yaml rather than a yarn.lock. The .node-version file exists to pin the interpreter.
The install path that matches the manifest is:
pnpm install --frozen-lockfileTwo variants exist for when the lockfile has to move, and the repo keeps both as named scripts:
pnpm install --no-frozen-lockfileA preinstall lifecycle script runs node preinstall.js before pnpm installs anything, and postcss.config.js, babel.config.js, tsconfig.json and .eslintrc.json sit at the root, so the type and lint layers are repo-wide rather than per package.
For first use, dev:viewer is the script that serves the app and dev:fast is the shortcut variant. Two archive-backed dev targets exist as well:
pnpm --filter @ohif/app run dev:orthancThat one assumes you have brought up the Orthanc compose file first, which the orthanc:up script does:
docker compose -f platform/app/.recipes/Nginx-Orthanc/docker-compose.yml upA dev:static script also exists.
master tags every package with a beta number, so npm installs can move under you
Branch naming in this project encodes how finished the code is, and the consequence reaches into your dependency graph. Code on master has passed code review and automated tests, yet every package there is published under a beta number, which is the project's own description of a branch that may not be deemed ready for production.
Work that is deemed stable gets cut onto its own branch, where a critical bug found afterwards is fixed with a minor bump on that same branch. Master is always ahead of it, and container builds are published for both lines, so you have a real choice between a moving target and a frozen one.
The choice has a cost either way. A team on master inherits an upgrade treadmill across every @ohif package it depends on. A team on a frozen branch inherits a slower cadence but must cut its own extension branches against the matching major, and it inherits the gap between what it forked against and whatever shipped afterwards.
The repository is not archived and the last push was on 2026-11-02, so the project itself is moving.
The Dockerfile cannot run a frozen install, and the comment explains why
The container build is the clearest failure mode in the repository, because it is documented in the file itself. The Dockerfile has two stages: it builds the React application, then serves the output from an Alpine Linux Nginx image. Build context matters, the file comment says to set the context to the project root directory.
The image is pinned and the package manager is installed globally in one line:
FROM node:24.15.0-slim as builderRUN npm install -g pnpm@12Now the catch. Stage one copies package manifests only, then runs the install before the source is copied. The file states that --no-frozen-lockfile is kept there, unlike CI, because .dockerignore excludes platform/docs, so the lockfile's docs importer has no manifest in the build context and a frozen install would fail. pnpm reconciles by dropping the docs importer.
Two consequences follow. The image build resolves packages against a manifest set that differs from the working tree, so a reproducible local install and a reproducible image are not the same operation. And preinstall.js must already be present in that early copy, since the root preinstall lifecycle script runs during pnpm install and would otherwise fail with MODULE_NOT_FOUND. Anyone editing the workspace layout has to check both the Dockerfile comment block and .dockerignore together.
Static files and Nginx, against the assumption that a viewer is a workstation
The difference in approach matters more than the feature list. A conventional diagnostic workstation ships signed, installed software with its own rendering stack, its own database and its own update channel. OHIF Viewers builds to static assets and puts a web server in front of them, which the Dockerfile states as its purpose: packaging the application with a web server capable of hosting it as static content.
What that buys you is deployment by file copy, a UI delivered as a component library at ui.ohif.org, and customization that lives in packages rather than in a fork. What it costs you is a Node 24 and pnpm 12 toolchain in the build path. Offline use is a supported capability, so a disconnected reading room is a designed case rather than an accident, but the archive side of that arrangement is yours.
The visual surface is unusually broad for a single application: volume rendering, slide microscopy, PDF and DICOM Structured Report rendering, and a lesion tracker all sit in the same project. That breadth is the trade-off. It is one codebase carrying several reading workflows, so a configuration that serves one department well can be a poor fit for the next one.
An eight-year rewrite and a two-tier support channel shape the upgrade bill
Terms are the cheapest part of the decision. Permissions here are permissive: commercial and academic use is fine and your own extension modifications need not be published.
The bill shows up elsewhere. The Viewer has been rebuilt from the ground up after more than 8-years of integrating with many companies and organizations, which means the code you adopt today is not the code those integrations were written against. The repository's own top-level entries, including CUSTOMIZATION_TYPING_PLAN.md and a react compiler budget pair, are a sign that typing and build budgets are still being negotiated.
Support is split in two. Community problems go to the issue tracker and a Slack channel; commercial support, academic collaborations and common questions go through a separate Get Support channel. The community repository is the substrate, and the Get Support channel is the route for commercial support. Decide early which one you are relying on, because it changes how you triage a regression on a frozen branch.
Editorial conclusion
Imaging teams that already run a DICOMweb archive and want a viewer they can change without maintaining a fork should build on OHIF Viewers, which is the case the extension system was designed around. Teams that need a fixed diagnostic workstation for one modality, or that cannot put a Node 24 and pnpm 12 toolchain in front of their deployment pipeline, should buy that instead. Verify three things first: run pnpm install --frozen-lockfile on Node 24 or newer and confirm the docs importer in the lockfile does not break the install, build with pnpm --filter @ohif/app run build:viewer and check the static output against your own archive, and read the frozen-lockfile warning in the Dockerfile if you plan to ship a container rather than files.
Frequently asked questions
What is OHIF Viewers and who is it for?
It is a zero-footprint medical image viewer built by the Open Health Imaging Foundation as a progressive web application with out-of-the-box support for archives that speak DICOMweb. It suits radiology and oncology teams that need to adapt the viewer through its extension system.
What package manager and Node version does OHIF Viewers require?
The root package.json pins packageManager to [email protected] and requires node >=24 with pnpm >=12, and the repository ships pnpm-lock.yaml. The requirements section in the README still names Yarn 1.20.0+, so follow the manifest instead.
Can I customize OHIF Viewers without forking it?
Every core feature is built on the project's own extension system, which covers 2D and 3D viewing, MPR, MIP, segmentation rendering, access control and context specific toolbar and side panel content. New functionality can be added and maintained privately without forking.
Which OHIF Viewers branch should production use?
Master is the latest dev branch, and its code may not be deemed ready for production; packages there carry beta numbers. Stable work moves onto its own branch, where a critical bug found afterwards is fixed with a minor bump on that same branch.
How is the OHIF Viewers Docker image built?
The Dockerfile has two stages: it builds the React application, then serves the static output from an Alpine Linux Nginx image, with build context set to the project root directory. Stage one copies only package manifests before running pnpm install, and it keeps --no-frozen-lockfile because .dockerignore excludes platform/docs and a frozen install would fail.
Under what terms can I use OHIF Viewers?
Commercial and academic use is permitted, and your own extension modifications need not be published. The no-warranty clause means clinical validation of any configuration you build on it stays with your team.
Official sources
Was this useful?