Fact-checked by Grok 2 weeks ago

Operating environment

An operating environment in refers to the integrated setup of software and components, built upon an underlying operating system, that enables the execution of applications and provides enhanced functionality such as task switching, windowing, and . It includes the operating system as its foundation along with supporting elements like , communication software, and third-party libraries to ensure compatibility and interaction with external resources. The term is used in various contexts, including historical software layers, enterprise standard configurations, and modern ecosystems. Historically, operating environments emerged in the mid-1980s to address limitations in early personal computing systems, particularly around , by introducing tools like Terminate and Stay Resident (TSR) programs for multitasking and expanded memory specifications to overcome the 640KB constraint. Early examples include IBM's TopView (1985), Microsoft's (1985), and Quarterdeck's DESQview (1985), which provided graphical interfaces and without replacing the base OS. By the 1990s, these evolved into more comprehensive systems, such as (1993), blurring the lines between operating environments and full-fledged operating systems. Key components of an operating environment typically include the core operating system version, hardware specifications (e.g., modern processors and graphics cards), runtime libraries, virtual machines, and system calls that handle inputs/outputs with the external world. In enterprise settings, a Standard Operating Environment (SOE) standardizes these elements across an organization's , incorporating predefined software collections and configurations to streamline deployment, patching, and . SOEs reduce complexity for large-scale deployments, automate to minimize errors, and ensure across physical, virtual, and cloud-based systems. Modern operating environments also address advanced challenges like cybersecurity in devices, where factors such as environmental interference (e.g., RF signals) and contextual usage (e.g., location) influence system design and security protocols. Tools like for monitoring system calls facilitate debugging and reproduction of these environments in experimental or production scenarios. Overall, operating environments remain essential for optimizing software performance, interoperability, and reliability in diverse computing ecosystems.

Definition and concepts

Core definition

In computing, an operating environment is middleware software that operates as an intermediary layer between the underlying operating system (OS) and application software, delivering a user interface (UI) and application programming interface (API) to improve usability and development efficiency without supplanting the core OS functions. This setup allows applications to interact with system resources through standardized abstractions, streamlining user experience and software integration. The term originated in the to characterize software shells or frameworks designed to augment basic OSes, such as , by introducing advanced features like windowing and task management within a cohesive framework. During this period, as personal expanded, operating environments emerged to address limitations in command-line interfaces, enabling more intuitive graphical interactions while relying on the host OS for fundamental operations. While historically focused on such software extensions, the term now also encompasses broader configurations, including hardware specifications and standardized enterprise setups like Standard Operating Environments (SOEs). Unlike a complete OS, an operating environment does not manage hardware directly, such as memory allocation or device drivers at the kernel level, but instead facilitates the unified execution of multiple applications through shared UI elements and APIs. Its key characteristics include an emphasis on enhancing user interaction via intuitive interfaces and the abstraction of OS complexities to simplify application development and deployment.

Key components

The layer forms the foundational interaction mechanism in an operating environment, enabling users to engage with applications and system resources through either text-based shells—such as command-line prompts enhanced with menu-driven navigation—or graphical elements including windows, icons, menus, and pointers that facilitate intuitive point-and-click operations. API provision constitutes a core structural element, offering standardized interfaces that allow applications to indirectly access underlying operating system services, such as wrappers for file handling, allocation, and device interactions, thereby promoting portability and consistency across software without direct dependencies. within an operating environment encompasses abstractions for basic multitasking and task switching, typically implemented via models where applications voluntarily yield control, alongside simplified allocation mechanisms that avoid deep kernel-level interventions to maintain operation. Integration tools enhance among applications, including cut-and-paste functionalities supported by a shared for data transfer and specialized protocols for inter-application communication that are tailored to the environment's architecture. provides limited, environment-specific support for peripherals like mice, keyboards, and displays, ensuring uniform application behavior across compatible by encapsulating device-specific details into higher-level calls.

Historical development

Early text-based environments

Early text-based operating environments emerged in the 1970s on mainframes and minicomputers, enabling interactive command-line access and batch processing for multiple users without requiring dedicated hardware for each task. These systems shifted computing from purely batch-oriented processing to time-sharing models, where users could submit commands via terminals connected to central processors. On IBM mainframes, the Time Sharing Option (TSO), introduced in 1971 as an extension to the OS/360 Multiprogramming with a Variable Number of Tasks (MVT) configuration, provided a basic interactive environment through line-mode terminals, supporting command execution, job submission, and basic editing for program development. Similarly, the UNIX operating system, developed at Bell Labs starting in the early 1970s, incorporated shells as its primary interface; the Bourne shell, authored by Stephen Bourne and released in 1977 with UNIX Version 7, introduced a robust command-line interpreter with scripting features for automating batch jobs and file manipulations. Earlier, the Thompson shell in Version 7 UNIX (1971) provided basic command interpretation, while Digital Research's CP/M (1974) used the Console Command Processor (CCP) for similar interactive command handling on microcomputers. Key innovations in these environments included menu-driven interfaces, which enhanced usability by displaying selectable options via keyboard navigation, reducing the need for memorized commands and appearing in mainframe utilities by the mid-1970s. Examples of early text shells include TSO's command processor for mainframe interactions and extensions to MS-DOS's , which from added batch scripting to support sequential command chaining on personal computers. These environments were limited by the absence of visual elements, relying entirely on keyboard input for text commands and enforcing largely sequential processing, which constrained concurrent operations and user feedback to printed or terminal output. This sequential nature often required users to wait for command completion before proceeding, highlighting the need for more responsive interfaces. Despite these constraints, the standardization of command vocabularies in systems like UNIX shells and TSO significantly reduced the reliance on custom application integrations, fostering reusable scripts and portable workflows across hardware. These foundational text-based systems paved the way for the more specialized environments of the mid-1980s.

DOS operating environments

In the mid-1980s, several operating environments emerged as graphical shells layered atop MS-DOS or PC-DOS, extending the capabilities of these text-based systems to support early multitasking and user interfaces on IBM PC-compatible hardware. Digital Research's GEM Desktop, announced in September 1984 and released in 1985, provided a portable graphical environment compatible with MS-DOS 2.0 or higher, featuring icon-based file management and mouse-driven interactions. IBM's TopView, shipped in March 1985, offered a text-mode multitasking shell for PC-DOS, allowing multiple DOS applications to run in resizable windows. Microsoft's Windows 1.0, launched on November 20, 1985, functioned as a 16-bit graphical shell over MS-DOS, introducing tiled windows and basic accessories like Notepad and Paint. Quarterdeck's DESQview, released in July 1985, delivered a text-mode windowing system for MS-DOS or PC-DOS, emphasizing efficient multitasking on limited hardware. These environments collectively addressed the single-tasking limitations of DOS by enabling users to launch and switch between applications without rebooting, marking a transitional step toward more integrated computing experiences. Key features introduced by these DOS shells included , where applications voluntarily yielded control to allow others to run, and windowing systems that permitted overlapping or tiled application views for improved productivity. supported icon-driven desktops with drop-down menus and a trash bin for file operations, mimicking the of integrated software suites like word processors and spreadsheets. TopView and DESQview focused on text-mode windows for DOS programs, while added rudimentary graphical elements such as icons, menus, and a mouse-compatible to streamline and reduce reliance on command-line inputs. These innovations allowed users to run multiple tools simultaneously, such as a alongside a , fostering a of integration previously absent in DOS. Technically, these environments relied on terminate-and-stay-resident (TSR) programs to manage memory and handle task switching, loading into the system's to intercept interrupts without altering the underlying OS. However, they were constrained by the PC architecture's 640 KB limit on , which included space for itself, applications, and TSRs, often forcing users to optimize configurations to avoid fragmentation. Multitasking remained rather than preemptive, meaning a misbehaving application could monopolize the CPU until manually interrupted, as the shells lacked hardware-level protection for true parallelism. Minimum requirements varied, with needing 256-384 KB of depending on version, while required at least 256 KB plus a . In terms of market impact, DOS shells like introduced the for inter-application data sharing, enabling users to copy text or between programs and reducing dependence on monolithic suites such as , which bundled , , and database functions into one package. This modularity encouraged the development of specialized applications, such as Microsoft's Excel, which could leverage windowing for side-by-side use with other tools, gradually eroding the dominance of all-in-one solutions by the late 1980s. Adoption was modest due to hardware constraints and a steep for non-technical users, but these environments popularized concepts like drag-and-drop file handling in and scalable windows in DESQview. By the early 1990s, these DOS-based shells declined as hardware advancements—such as increased and 386 processors—enabled full-fledged operating systems like (1990) and , which offered multitasking and native support without DOS dependencies. Their legacy endures in modern user interfaces, influencing foundational elements like overlapping windows, menu bars, and icon metaphors that became standards in subsequent graphical environments.

Evolution beyond DOS

In the late 1980s and 1990s, operating environments began transitioning from the limitations of DOS shells toward hybrid systems that integrated graphical user interfaces with underlying kernels for enhanced functionality and stability. Windows 3.x, released in May 1990, represented a significant advancement by providing a robust graphical shell atop , supporting execution for better and among applications. This environment improved upon earlier DOS overlays by offering a consistent with Program Manager and , while still relying on DOS for file operations and legacy compatibility. By 1995, Microsoft released Windows 95, which marked a pivotal evolution toward a more unified operating environment with a 32-bit that preemptively multitasked protected-mode applications, reducing reliance on to primarily boot loading and 16-bit legacy device support. This integration allowed for seamless handling of both 16-bit and 32-bit code, introducing features like the and that became staples in modern desktop environments. Parallel developments in Unix and Linux ecosystems emphasized networked graphical layers decoupled from the kernel. The , initiated in 1984 at MIT's , evolved into a standard protocol for bitmap displays over Unix, enabling remote graphical sessions and serving as the foundation for subsequent desktop environments. In the mid-1990s, this foundation supported full desktop shells like , announced in October 1996 by as a consistent graphical for Unix systems using the Qt toolkit for cross-platform widget development. Similarly, emerged in 1997, founded by and Federico Mena to create a free desktop environment leveraging the GTK+ library, prioritizing accessibility and modularity on GNU/ and other systems. Entering the 2000s, operating environments shifted toward fully integrated desktop paradigms with native UI layers and app runtimes. Apple's Aqua interface, unveiled in 2000 and debuting in (2001), provided a fluid, object-oriented graphical layer built on for hardware-accelerated rendering, transforming the into a Unix-based system with Aqua as its defining visual and interaction environment. In mobile contexts, Android's runtime environment, initially powered by the Dalvik virtual machine from 2008, evolved to the Android Runtime (ART) in 2014 for , enabling efficient app execution within a Linux-based while abstracting hardware specifics through layered frameworks. Key evolutions during this period included the adoption of preemptive multitasking, which in allowed the to tasks for fairer , contrasting DOS's model, and in Unix variants like those supporting X, it was inherent to the multi-user design. Hardware acceleration support proliferated through in environments like X11, where extensions such as XRender (2000) offloaded to GPUs, enhancing performance for 2D and later 3D graphics. Cross-platform further standardized development: , originating in 1991 from Trolltech, facilitated portable GUI creation across Windows, Unix, and embedded systems, powering KDE's widget set, while , released in 1998 as a free alternative, underpinned and emphasized theming and internationalization. Contemporary trends extend operating environments beyond local hardware into distributed and virtualized realms. Cloud-based systems, such as web UIs in platforms like AWS Management Console, deliver remote desktop-like interactions via browser runtimes, abstracting underlying infrastructure for scalable access. technologies like , introduced in 2013, redefine runtime environments by packaging applications with dependencies into isolated, portable units that mimic lightweight operating systems, supporting in cloud-native architectures without full OS overhead.

Types and classifications

Graphical operating environments

Graphical operating environments are GUI-based software frameworks layered atop a base operating system, such as , to provide windowing, multitasking, and visual interaction without replacing the underlying OS. These emerged in the 1980s to overcome limitations, using icons, windows, and input for intuitive application management and task switching. The conceptual foundations trace to the (1973), which introduced a bitmap-based with a for selecting icons and manipulating windows, influencing later personal computing interfaces. In 1985, Microsoft's debuted as a graphical for , offering tiled windows, a basic menu system, and support for running DOS applications alongside simple graphical programs. That year, Digital Research's (Graphics Environment Manager) provided a similar DOS-compatible with menus, dialog boxes, and icons for file management and application launching. These environments relied on graphics libraries and drivers compatible with early PC hardware, such as CGA or EGA standards, to visual elements. They supported basic theming and through alternatives to input. By enabling visual , they improved productivity for users transitioning from command-line interfaces, though they incurred overhead from memory constraints of the era.

Text-based and command-line environments

Text-based and command-line environments encompass non-graphical interfaces for OS interaction, but in the context of operating environments, they refer to text-mode extensions that added multitasking and windowing to base systems like via commands and shell-like interpreters. These prioritized efficiency in resource-limited setups, ideal for servers or early , using terminal-like consoles for task execution and automation. Historical precedents include the command processor in , a 1970s OS from that offered basic text command interpretation for microcomputers. Key 1980s examples are IBM's TopView (1985), a text-mode multitasking for that allowed overlapping windows for running multiple applications simultaneously, and Quarterdeck's DESQview (1985), an advanced environment supporting dynamic window resizing, clipboard sharing, and compatibility with TSR programs. Features included command for data flow between tasks and scripting for batch operations, concepts rooted in early Unix but adapted for . Remote access via protocols like (RFC 854) enabled network-based text interactions, later secured by SSH (RFC 4251). These environments supported administration and development in constrained hardware, evolving from pure command-line shells to integrated multitasking tools while maintaining low overhead.

Relation to other systems

Distinctions from operating systems

An operating system serves as the foundational software layer that directly interacts with , managing essential resources through its , which handles tasks such as CPU scheduling, allocation, processing, and drivers with privileged (kernel-mode) access to ensure system stability and security. In contrast, an operating environment functions as a higher-level intermediary or layer that operates in user space without kernel privileges, relying on the underlying OS for hardware management while providing abstractions for application execution, such as standardized and user interfaces. This distinction ensures that operating environments cannot perform low-level operations independently and are designed to enhance atop a complete OS rather than replace its core functions. The scope of an operating system encompasses core system services, including and management, operations, networking, and enforcement through mechanisms like authentication and access controls, forming the bedrock for all software execution. Operating environments, however, concentrate on higher-level orchestration of applications, ensuring consistent interactions via graphical or text-based interfaces, window management, and integration of productivity tools, without delving into or . For instance, while an OS might enforce to prevent application crashes from affecting the system, an operating environment coordinates how applications appear and interact visually, such as through drag-and-drop functionality or menu systems. Examples of overlap and misuse highlight these boundaries, particularly in early personal computing. Microsoft's initial Windows releases, such as in 1985 and in 1987, were explicitly marketed as graphical operating environments extending , providing a windowing interface and multitasking facade atop the DOS kernel without supplanting its hardware management role; over time, Windows evolved into a full OS with the introduction of the NT kernel in the 1990s. In modern contexts, this mirrors the separation in Linux distributions, where the handles foundational OS duties like device drivers and process scheduling, while desktop environments such as KDE Plasma or serve as replaceable user-facing layers focused on UI consistency and application launching. These distinctions carry practical implications for modularity and maintenance. Operating environments are inherently replaceable and customizable, allowing users to switch between options like and on the same installation via display manager selection at login, without altering the underlying OS; this flexibility promotes user choice and innovation in interfaces. Conversely, operating systems are foundational and not easily swapped, as replacing a requires rebuilding the entire , potentially disrupting and . Historically, the term "operating environment" gained prominence in the 1980s to describe extensions and shells—like Microsoft's or third-party GUIs such as DESQview—avoiding the implication of a complete OS while emphasizing their role as enhancements for the command-line ecosystem.

Connections to runtime and application frameworks

Operating environments serve as foundational layers that integrate with systems to enable the execution of portable applications, providing a consistent interface between the underlying operating and application code. For instance, the Runtime Environment (JRE) operates within operating environments like Windows or shells, supplying the necessary and class libraries to run Java applications seamlessly alongside native components. This integration is facilitated by tools such as the JDesktop Integration Components (JDIC), which allow Java applications to access native features, including dialogs, trays, and services, thereby embedding them as first-class elements in the host environment. Similarly, in mobile contexts, the (ART) functions as an integral part of the Android operating environment, compiling applications ahead-of-time to optimize performance and manage memory within the 's graphical and service layers. ART replaces the earlier Dalvik , enabling efficient execution of Android apps and services directly within the OS's context. Application frameworks further deepen these connections by leveraging operating environments to deliver user interfaces and cross-platform compatibility. The .NET Framework, for example, ties into Windows operating environments through its (CLR), which handles code execution while interacting with the desktop shell for UI rendering via Windows Presentation Foundation (WPF) or . This allows developers to build applications that natively utilize the environment's event handling and resource management without direct OS calls. , a framework for desktop applications, embeds a browser engine and runtime to run web-based UIs within various operating environments, such as macOS, Windows, or , abstracting platform-specific details like window management and file access. In web-centric scenarios, frameworks like operate within browser-based operating environments, where the browser acts as a runtime host, rendering dynamic UIs through the (DOM) and while relying on the host OS environment for display and input handling. These integrations offer significant benefits for developers, primarily through abstraction layers that separate concerns: the operating environment manages events, windowing, and user interactions, while the oversees code interpretation, memory allocation, and execution safety. This division promotes portability, as applications written for one can adapt to different environments with minimal changes, reducing development overhead and enhancing consistency across platforms. However, challenges arise in maintaining version compatibility between and environments; for example, updating the .NET Framework from version 4.6.1 to 4.8 may introduce behavioral shifts in application compatibility, requiring targeted testing to avoid errors or deprecated feature issues. Security considerations also play a critical role, with sandboxing mechanisms isolating processes from the broader operating environment to prevent unauthorized access or exploits—such as in , where app sandboxes limit interactions to declared entitlements, mitigating risks from malicious code execution.

References

  1. [1]
    What Is an Operating Environment? — Definition by Techslang
    Mar 13, 2025 · An operating environment is the place where users run applications, software, or programs. It is not necessarily a full operating system ...
  2. [2]
    operating environment - CLC Definition
    - **Definition**: Operating environment refers to the essential control programs in a computer, including the operating system, databases, and communications software.
  3. [3]
    Operating Environment - an overview | ScienceDirect Topics
    An operating environment refers to the version information about the operating system and any third-party components that may interact with it.
  4. [4]
    What is an SOE? - Red Hat
    Jan 8, 2019 · An SOE is a standard operating environment, or a specific computer operating system and collection of software that an IT department defines as a standard ...
  5. [5]
    Microsoft Windows Operating Environment, Version 1.0
    ... Windows 1.0, running on top of MS-DOS and supporting only tiled rather than ... Microsoft Windows Operating Environment, Version 1.0. Appears In ...
  6. [6]
    What Is an Operating Environment? - Computer Hope
    Dec 9, 2023 · With computer software, an operating environment is the area from which a program is run. For example, Microsoft Word may run in the ...<|control11|><|separator|>
  7. [7]
    Doing Windows, Part 1: MS-DOS and Its Discontents
    Jun 22, 2018 · As it happens, when we look closer at what a GUI-based operating environment ... 1980s to find some way around MS-DOS's memory constraints.
  8. [8]
    Section II: Programming in the MS-DOS Environment - PCjs Machines
    The operating environment provides additional services, such as common menu and forms support, that simplify program operation and make the user interface more ...
  9. [9]
    Definition of GUI (Graphical User Interface) - Gartner
    A comprehensive GUI environment includes four components: a graphics library, a user interface toolkit, a user interface style guide and consistent applications ...
  10. [10]
    1 Introduction to Windows Concepts - Pearsoncmg.com
    Windows 3.1 also introduced a new subsystem, Win32s, a 32-bit operating environment that runs on the 16-bit Windows 3.1 platform. Win32s is a subset of Windows ...
  11. [11]
    Windows 3.0 Operating System
    Dec 22, 2023 · Applications are running in cooperative multitasking and can now use up to 16 Mbytes of RAM. The user control during the graphical installation ...
  12. [12]
    PERSONAL COMPUTERS; WINDOWS ARE OPEN AT LAST
    Feb 25, 1986 · ... operating environment is essentially just a patch, or add-on, to ... Windows provides a notepad, a clipboard for transferring data from ...
  13. [13]
    Clipboard (computing) - Informatics Science | Wiki eduNitas.com
    The semantics of the clipboard facility varies from one operating environment to another, and can also vary between versions of the same system. They can ...
  14. [14]
    Time-sharing | IBM
    In the early 1960s, an experimental time-sharing system was launched at MIT on a modified IBM 709. MIT added a typewriter input so that an operator could ...
  15. [15]
    [PDF] IBM System/360 Operating System: Time Sharing Option Guide
    TSO Trace Program: The TSO Trace Writer Program provides a detailed history of what the system does over a period of time. The Trace Program records a ...
  16. [16]
    [PDF] An Introduction to the UNIX Shell - CL72.org
    Nov 1, 1977 · The shell is a command programming language that provides an interface to the UNIX† operating system. Its features include control-flow ...
  17. [17]
    How the Graphical User Interface Was Invented - IEEE Spectrum
    Menus—functions continuously listed onscreen that could be called into action with key combinations—were commonly used in defense computing by the 1960s. But it ...Missing: driven | Show results with:driven
  18. [18]
    The Lost Art of TSR Programming - Chris Miller's 5th Blog
    Mar 11, 2008 · That shook some memories out of the cranial storage device. I used to write TSR programs, more formerly known as Terminate and Stay Resident.Missing: history | Show results with:history
  19. [19]
    What is a TSR? - DOS Days
    A TSR (Terminate and Stay Resident) program is a piece of software that is designed to stay in memory once run so you can use it alongside another program.Missing: history | Show results with:history
  20. [20]
    The UNIX System -- History and Timeline
    1979, Seventh Edition, It was a "improvement over all preceding and following Unices" [Bourne]. It had C, UUCP and the Bourne shell. It was ported to the VAX ...
  21. [21]
    The history of PCs | Microsoft Windows
    Dec 31, 2024 · The launch of Windows 1.0 in 1985 marked the beginning of a new era in personal computing. Windows provided a graphical user interface (GUI) ...
  22. [22]
    [PDF] The GEM Operating System Handbook - Bitsavers.org
    In September of 1984, Digital Research made the first announcement of the ... Enter DOS Commands converts the GEM Desktop into a standard PC-DOS.<|separator|>
  23. [23]
    IBM TopView - EDM2
    Jul 26, 2023 · In addition to the shell itself IBM sold a small number of TopView aware DOS applications. Versions. TopView 1.00 (1985-03-05); TopView 1.01 ( ...
  24. [24]
    Definition of DESQview - PCMag
    An earlier multitasking, windowing environment for DOS from Quarterdeck. In 1985, DESQview was the first serious multitasking program for the DOS PC.
  25. [25]
    The 640K memory limit of MS-DOS - OSnews
    Jun 10, 2018 · The utter most important Conventional Memory was limited to 640 KiB! The Legend teaches us that Bill Gates once declared that “640 KB ought to be enough for ...Missing: shells cooperative multitasking TSR
  26. [26]
    If DOS is single-tasking, how was multitasking possible in old ...
    Mar 8, 2014 · Multitasking was cooperative, just like in old versions of MacOS (though unlike Multitasking DOS 4. x, which sported preemptive multitasking). ...<|separator|>
  27. [27]
    GUIdebook > ... > Windows > Windows 1.0 ad
    Feb 22, 2005 · Print Spooler – Print files from Windows applications while running other programs. Clipboard – View information copied from applications.<|separator|>
  28. [28]
    The History of DOS (Disk Operating System) - Wizmo Inc.
    The decline of DOS began in the mid-1990s as graphical user interfaces (GUIs) became more popular. Microsoft's introduction of Windows 95 marked a significant ...Missing: UIs | Show results with:UIs
  29. [29]
    The Evolution of the Windows Command-Line
    Jun 27, 2018 · Windows 1.x, 2.x, 3.x, 95, and 98, all ran atop an MS-DOS foundation and heavily relied upon their MS-DOS foundations. Note: Windows ME ...
  30. [30]
    In Windows 3.1 and Windows 95, what is a "grabber"?
    Nov 27, 2023 · Windows 3.0 Enhanced Mode introduced the ability to run MS-DOS programs in a virtual machine. This by itself was already quite an achievement, ...<|separator|>
  31. [31]
    What was the role of MS-DOS in Windows 95? - The Old New Thing
    Dec 24, 2007 · MS-DOS served two purposes in Windows 95. It served as the boot loader. It acted as the 16-bit legacy device driver layer. When Windows 95 ...
  32. [32]
    Software & Languages | Timeline of Computer History
    Windows 95 was a major improvement over the previous Windows 3.1, adding features such as “Plug and Play” for more easily installing new peripherals, as well ...
  33. [33]
    KDE Timeline
    In 1996, Matthias Ettrich announced the creation of Kool Desktop Environment (KDE), a graphical interface for Unix systems, built with Qt and C ++ and designed ...
  34. [34]
    GNOME -- About
    The GNOME project was founded in 1997 by two students, Miguel de Icaza and Federico Mena. Their goal: to take on the tech giants of the day, and build a ...
  35. [35]
    [PDF] Oral History of Bertrand Serlet
    Sep 20, 2023 · ... Aqua and the Aqua UI was very successful. It was very fresh ... So in a different history path, maybe Apple should have kept it closed.
  36. [36]
    Platform architecture | Android Developers
    May 20, 2024 · Prior to Android version 5.0 (API level 21), Dalvik was the Android runtime. If your app runs well on ART, then it can work on Dalvik as ...Missing: environment history
  37. [37]
    Docker: Accelerated Container Application Development
    Docker is a platform designed to help developers build, share, and run container applications. We handle the tedious setup, so you can focus on the code.Docker Desktop · Container image · Why Docker Discover what... · Get StartedMissing: trends | Show results with:trends
  38. [38]
    [PDF] An introduction to graphical users interfaces and their use by CITIS
    GUIs have become pervasive on both personal computers (PCs) and workstations. GUIs are powerful tools for the end-user and the application program developer ...
  39. [39]
    Xerox Alto - CHM Revolution - Computer History Museum
    Removable data storage. Networking. A visual user interface. Easy-to-use graphics software. “What You See Is What You Get” (WYSIWYG) printing, with ...
  40. [40]
    GEM on the Atari ST - Book - Computing History
    GEM received widespread use in the consumer market from 1985, when it was made the default user interface built in to the TOS operating system of the Atari ...
  41. [41]
    [PDF] Byte Aug 1985 - Vintage Apple
    Aug 1, 1985 · ... AMIGA PERSONAL COMPUTER by Gregg Williams. Ion Edwards. and Phillip ... oriented pro gramming language. The programs. currently ...
  42. [42]
    Use the Finder on Mac - Apple Support
    View files and folders on your Mac. Click items in the Finder sidebar to view your apps, documents, downloads, and more. You can customize the sidebar to change ...Customize the Finder sidebar · Sync content between your... · Use the Preview pane
  43. [43]
    New to Linux? 5 desktop environments I recommend you try first
    Sep 3, 2025 · 2. Cinnamon. Imagine KDE Plasma without the modern looks. That's how I see Cinnamon. This desktop environment came about after the GNOME ...KDE Plasma · Cinnamon · MATE · Pantheon
  44. [44]
    X.Org
    May 4, 2023 · The X.Org project provides an open source implementation of the X Window System. The development work is being done in conjunction with the freedesktop.org ...Download · X.Org Foundation · Documentation · Releases/7.7
  45. [45]
    Wayland
    Wayland is a replacement for the X11 window system protocol and architecture with the aim to be easier to develop, extend, and maintain.
  46. [46]
    Comparing Text-based and Graphic User Interfaces for Novice ... - NIH
    GUI interface was better for novice users. For novice users there was a learning transfer effect from TUI to GUI. This means a user interface is user-friendly ...
  47. [47]
    The Graphical User Interface: An Introduction
    A good GUI makes an application easy, practical, and efficient to use, and the marketplace success of today's software programs depends on good GUI design.
  48. [48]
    Command Line Interface - GeeksforGeeks
    Jul 26, 2025 · The Command Line Interface (CLI) is a text-based tool for interacting with a computer's operating system using typed commands.
  49. [49]
    Zsh
    This site provides an index to Zsh information and archives. Zsh is a shell designed for interactive use, although it is also a powerful scripting language.
  50. [50]
    Early Digital Research CP/M Source Code - CHM
    Oct 1, 2014 · Kildall started a company called Digital Research, Inc. (DRI) in Pacific Grove, California to develop and market CP/M, and for years it was the ...
  51. [51]
    Unix Is Born and the Introduction of Pipes - CSCI-E26
    Pipes had been created by the time the Version 3 Unix Manual appeared in February 1973. The date listed for the creation of pipes is January 15, 1973(41). Not ...
  52. [52]
    RFC 4251 - The Secure Shell (SSH) Protocol Architecture
    The Secure Shell (SSH) Protocol is a protocol for secure remote login and other secure network services over an insecure network.
  53. [53]
    RFC 854 - Telnet Protocol Specification - IETF Datatracker
    The TELNET Protocol provides a standard for bi-directional, eight-bit byte oriented communication, interfacing terminal devices and processes.
  54. [54]
    Linux command in DevOps - GeeksforGeeks
    Sep 30, 2025 · Linux commands are essential for DevOps engineers, as they make system administration, automation, and troubleshooting fast and reliable.
  55. [55]
    Azure Command-Line Interface (CLI) documentation - Microsoft Learn
    Official product documentation for Azure command-line interface (Azure CLI). Azure CLI is a cross-platform command-line tool for managing Azure resources.Install the Azure CLI on Windows · Query command output · What is the Azure CLI?
  56. [56]
    The Linux Kernel documentation — The Linux Kernel documentation
    ### Summary: Distinctions Between Linux Kernel and Desktop Environments
  57. [57]
    Solved: difference between os and oe - HPE Community
    Dec 10, 2005 · The operating system is essential to the computer's ability to function whereas an operating environment sits on top of the os. Prior to Windows ...Operating Environments - Hewlett Packard Enterprise CommunityWhat is Enterprise Operating Environment? - HPE CommunityMore results from community.hpe.com
  58. [58]
    What Is a Desktop Environment in Linux? - Baeldung
    Mar 19, 2025 · Desktop Environment is a bundle of components that provide users with a graphical user interface (GUI) to more easily interact with their system.
  59. [59]
    https://www.kernel.org/doc/html/latest/internal-api-manuals.html
  60. [60]
    Linux For Beginners: What's A Desktop Environment? - Forbes
    Sep 17, 2018 · All our action happens with a graphical user interface, which is what a desktop environment is. Your file manager, windows, login screens, ...
  61. [61]
    The History of Microsoft - 1983
    Apr 1, 2009 · Microsoft unveils Windows, an extension of the MS-DOS operating system that provides a graphical operating environment. Windows features a ...Missing: early | Show results with:early
  62. [62]
    A Visual History: Microsoft Windows Over the Decades | PCMag
    Apr 4, 2025 · IBM's TopView actually made the cover in April 1985, while Windows didn't receive that honor until 1991. Even Microsoft Excel merited a PC ...
  63. [63]
    Desktop Environment (Change) - System76 Support
    Dec 15, 2023 · Pop!_OS Comes with GNOME by default. Follow these instructions to install additional desktop environments.
  64. [64]
    Can we switch desktop ( GNOME, KDE, etc ) within linux?
    Sep 8, 2012 · Yes. If you install the new desktop environment (KDE, GNOME, LXDE, XFCE, etc.) you should see a option appear on the login splash-screen.
  65. [65]
    https://www.kernel.org/doc/html/latest/development-tools-and-processes.html
  66. [66]
    A Brief History of Microsoft Windows | Network Wrangler – Tech Blog
    Jul 16, 2015 · Designed as an operating environment for MS-DOS rather than a complete operating system, Windows 1.0 was not a commercial success. However ...
  67. [67]
    Java SE Desktop Overview - Oracle
    The JDesktop Integration Components (JDIC) project aims to make Java technology-based applications ("Java applications") first-class citizens of current desktop ...
  68. [68]
    Android runtime and Dalvik - Android Open Source Project
    Aug 26, 2024 · Android runtime (ART) is the managed runtime used by apps and some system services on Android. ART and its predecessor Dalvik were ...
  69. [69]
    Overview of .NET Framework - Microsoft Learn
    Mar 29, 2023 · .NET Framework is a technology that supports building and running Windows apps and web services. .NET Framework is designed to fulfill the following objectives:
  70. [70]
    Electron: Build cross-platform desktop apps with JavaScript, HTML ...
    Electron embeds Chromium and Node.js to bring JavaScript to the desktop. Cross-platform Electron apps run natively on macOS, Windows, and Linux across all ...ElectronJs Apps · Application Packaging · Electron Releases · Electron homepageMissing: environments | Show results with:environments
  71. [71]
    Pods - Kubernetes
    Oct 28, 2025 · You need to install a container runtime into each node in the cluster so that Pods can run there. The shared context of a Pod is a set of Linux ...Pod Lifecycle · Create static Pods · Pod Concept Kubernetes · Sidecar ContainersMissing: UI | Show results with:UI