Oscilloscopes may look like specialized appliances, but many modern instruments are computers connected to precision acquisition hardware. OOS, a community project exploring an open source operating system for Rigol oscilloscopes, asks what engineers could do if that computing layer were open to inspection and modification. The answer could include custom interfaces, automated workflows and longer-lived laboratory equipment—but only if developers can safely preserve the instrument’s core measurement functions.
OOS is not an official Rigol product, a universal firmware upgrade or a finished replacement for every Rigol digital oscilloscope. It is an experimental software-development effort discussed through its repository, technical documentation and a detailed EEVblog project thread. Compatibility and implementation details can change as contributors learn more about the underlying hardware. Anyone considering an experiment should therefore treat the current repository—not forum summaries or assumptions based on a similar-looking scope—as the controlling source.
Why an oscilloscope needs an operating system
A digital oscilloscope contains much more than an analog front end and a display. Its software must coordinate acquisition memory, trigger controls, waveform rendering, storage, networking, user input and communication with programmable logic or dedicated measurement components. Many contemporary instruments use an embedded Linux platform for at least part of that work.
Manufacturers normally control this stack. Users receive a signed or packaged firmware image, a documented interface and periodic updates, but they rarely receive everything needed to rebuild the complete system. That arrangement supports validation and product consistency. It also means that interface changes, new workflows, security fixes and long-term support depend on the vendor.
OOS investigates a different model: an operating environment whose code can be studied, built and extended by the community. This is deeper than changing a theme or adding a remote-control application. The project potentially touches boot behavior, device access, graphics, input handling and communication with the scope’s internal measurement subsystems.
What OOS does—and what it does not do
The most important distinction is between an operating-system project, a firmware patch and an external control program. Those approaches operate at different layers and carry very different risks.
- Operating-system replacement: OOS aims to provide an alternative software environment on compatible hardware. It may need to boot the instrument, initialize supported devices and expose services required by applications.
- Firmware modification: A patch alters some part of the manufacturer’s existing image or configuration while retaining much of the original stack. Such modifications remain dependent on proprietary components and a particular firmware version.
- External instrument control: A computer sends commands over USB or LAN, usually through SCPI. The oscilloscope continues running its factory firmware, so the host does not replace the instrument’s internal operating system.
This distinction prevents a common misconception about Rigol scope hacking. A desktop application that downloads waveforms may be open source, yet the scope remains a closed appliance. Conversely, booting open software on the instrument does not reveal the design of its acquisition ASICs, FPGA logic, analog front end or proprietary measurement algorithms.
Supported models and hardware requirements
There is no responsible basis for assuming that OOS supports every DS, MSO, DHO or other Rigol family. Product names can cover multiple board revisions, component substitutions and firmware generations. Two scopes with similar interfaces may use different processors, displays, touch controllers, programmable logic or boot layouts.
As of November 2026, readers should verify support against the repository’s current compatibility information and open issues before downloading or building anything. The public discussion is evidence of active experimentation, not a permanent certification list. A model should be considered compatible only when the documentation explicitly names that model and, where applicable, its hardware revision. Planned targets, contributor reports and partially working ports are not equivalent to supported installations.
Hardware requirements are likewise target-specific. Developers may need a build computer, suitable removable media, a serial console or other debugging connection, and a proven way to restore the original software. Access to boot logs can be critical when the display does not initialize. Exact media layouts, image files, voltage levels and connection points must come from the project documentation; instructions for another Rigol digital oscilloscope should never be improvised.
How the software architecture differs from factory firmware
An open oscilloscope platform has to bridge two worlds. On one side are familiar operating-system components: a bootloader, Linux kernel, device tree, drivers, filesystem, graphics stack and user applications. On the other are instrument-specific systems such as acquisition control, triggers, calibration data, waveform memory and front-panel hardware.
The conventional computing side is comparatively approachable because established embedded Linux tools can be reused. The measurement side is harder. Hardware interfaces may be undocumented, initialization sequences may be known only to the manufacturer, and some functions may execute inside proprietary FPGA images or dedicated chips.
For that reason, project maturity cannot be judged solely by whether OOS reaches a graphical screen. A useful oscilloscope environment must reliably control acquisition, preserve calibration, report settings correctly and handle errors. Rendering a waveform is an encouraging milestone; demonstrating trustworthy measurements across channels, ranges, sample rates and trigger modes is a much higher bar.
Development status, installation and available features
OOS should be treated as oscilloscope firmware development rather than consumer-ready software. Repository commits, build instructions and issue reports show what contributors are actively implementing, while forum posts and the associated Hacker News discussion provide broader context. Neither community discussion should override the project’s current technical documentation.
Feature labels also require careful reading. A checked item may mean that a device was detected or a basic operation was demonstrated, not that the feature has been validated to laboratory-instrument standards. Users should distinguish among experimental code, partially functional drivers, developer previews and tested releases. If the repository does not explicitly document a measurement mode, protocol or model, it should not be represented as available.
Installation is not a single generic procedure. A prudent process is to identify the exact instrument and board revision, archive relevant factory information, build or obtain the matching OOS image, prepare the documented boot medium and confirm recovery access before changing persistent storage. If the project supports a non-destructive or removable-media boot path for a particular target, that is preferable for initial evaluation. It still does not eliminate risk: faulty low-level software can write to storage, misconfigure hardware or leave the scope unable to boot normally.
Why open software matters for electronic test equipment
The strongest case for open source test equipment is not simply that users can change colors or menus. Access to the software layer can make an instrument a development platform.
Custom measurement workflows
An engineer could design a task-specific interface that exposes only the controls needed for production testing, education or field diagnostics. Repetitive setup steps could be combined into a guided workflow, reducing operator error without requiring a separate computer beside the instrument.
Automation and scripting
A documented local API or scripting environment could automate captures, annotate results and coordinate measurements with other hardware. Developers might also experiment with direct data acquisition pipelines, subject to the bandwidth and access provided by the underlying measurement hardware.
New visualization interfaces
Open software could support specialized waveform views, accessibility improvements or displays tailored to a research project. These possibilities are not promises that OOS already implements every interface; they illustrate what an extensible platform could enable as drivers and APIs mature.
Longer equipment life
When a manufacturer ends software support, functioning laboratory hardware can become difficult to integrate into modern networks and workflows. Community-maintained software may help keep some older instruments useful. That benefit depends on documentation, maintainers and reproducible builds, however. Publishing code alone does not guarantee long-term maintenance.
OOS compared with conventional SCPI control
For most automation projects, SCPI remains the safer starting point. A script running on a workstation can configure the scope, trigger acquisitions and retrieve data while leaving factory firmware and calibration behavior intact. Standard commands also make it easier to substitute another instrument later.
OOS becomes relevant when the desired change must happen inside the scope: replacing the local interface, accessing hardware not exposed through SCPI, experimenting with device drivers or studying the embedded platform itself. That control comes with a larger engineering burden.
- Choose SCPI for repeatable remote measurements, production automation and low-risk integration.
- Consider OOS for operating-system research, laboratory equipment customization and development that requires local hardware access.
- Use both where appropriate: an open internal platform could still expose a standards-oriented remote interface.
SCPI is therefore not an inferior version of OOS. It solves a different problem and usually offers a much clearer boundary between experimental software and measurement integrity.
Risks that developers must take seriously
An oscilloscope is a calibrated measurement instrument, not merely an embedded Linux board with a screen. The consequences of an incorrect installation extend beyond a failed boot.
- Model mismatch: An image built for another board may use incompatible memory maps, storage layouts or peripheral settings.
- Failed recovery: Overwriting boot components or recovery partitions can turn a reversible experiment into a hardware repair job.
- Calibration integrity: Factory coefficients may reside in protected or poorly documented storage. Losing or misapplying them can invalidate measurements.
- Accuracy and safety: Software can display plausible results while using the wrong attenuation, timing or acquisition configuration.
- Incomplete hardware access: Proprietary FPGA logic and undocumented devices may prevent feature parity with factory firmware.
- Warranty implications: Opening the enclosure, attaching debug hardware or installing unofficial software may affect support and warranty coverage.
Open-source firmware does not automatically make the hardware open. Schematics, programmable-logic sources, calibration procedures and proprietary silicon may remain unavailable. OOS can improve transparency in the layers it controls without making every part of the instrument reproducible or auditable.
How to assess OOS before experimenting
- Record the exact model and revision. Photograph labels and boards where access is safe and permitted; do not rely on the front-panel family name.
- Read the compatibility table and issues. Look for recent reports involving the same hardware, not merely a related series.
- Check project activity. Review release notes, recent commits, unresolved installation failures and whether maintainers answer recovery questions.
- Separate demonstrations from validation. Confirm which acquisition, trigger, storage and interface functions are tested.
- Plan recovery first. Obtain the correct factory image through legitimate channels and understand the documented restoration method before booting OOS.
- Protect calibration data. Follow model-specific backup guidance and never assume a generic filesystem copy captures instrument constants.
- Use a noncritical scope. Do not begin with equipment needed for safety testing, compliance work or time-sensitive production.
- Verify against a reference. If measurements are enabled, compare amplitudes, frequency, timing and triggering with known signals across relevant settings.
Frequently asked questions
Is OOS officially supported by Rigol?
No. OOS is a community project and should not be presented as Rigol firmware, a manufacturer partnership or an approved upgrade. Questions about compatibility should be directed to the project’s current documentation and maintainers.
Can OOS be installed on any Rigol oscilloscope?
No. Compatibility depends on the exact model, board revision and development status. Similar product names do not establish support. If the current documentation does not explicitly list a target, assume it is unsupported.
Will an open operating system preserve measurement accuracy?
Not automatically. Accuracy depends on correct hardware control, calibration data and validation across operating modes. Experimental software should not be trusted for consequential measurements without independent verification.
Is OOS better than controlling a scope over USB or LAN?
It offers different capabilities, not an automatic improvement. SCPI control is usually safer for automation because factory firmware remains responsible for acquisition. OOS is more relevant when developers need to modify the instrument’s internal software environment.
Could OOS make an older scope useful for longer?
Potentially. Community software can provide new workflows and maintenance after official updates stop, but only for hardware that contributors understand and support. Proprietary components, missing documentation and limited maintainer time may still constrain its useful life.
A significant experiment, not a casual upgrade
OOS matters because it challenges the assumption that professional electronic test equipment must remain a closed software appliance. An open platform could encourage experimentation, auditable interfaces and new tools for engineers, researchers and the DIY electronics community. It could also reveal how difficult it is to separate a modern instrument’s user-facing software from its proprietary measurement core.
That makes the project valuable even before it reaches broad feature parity. Its success should be measured through documented compatibility, recoverable installation, transparent limitations and validated measurements—not simply by whether code boots. For interested developers, the right first step is careful study of the repository and current hardware notes. The soldering iron, debug cable and installation image should come later.