Container-First Endpoints: Another Path for EUC Innovation

For years, endpoint security has meant locking down the operating system. A new architectural idea asks a different question: how much operating system does an endpoint really need?

Every thin client strategy rests on the same quiet assumption. The device runs an operating system, the operating system runs a connection client, and IT’s job is to keep that stack hardened, patched, and consistent across hundreds or thousands of devices.

That model works, and it works well, thanks to years of engineering by endpoint OS vendors. Alongside it, a container-first, stateless approach is emerging. Rather than asking how to lock down an endpoint’s OS, it asks how little persistent OS state the endpoint needs in the first place.

This isn’t a black-and-white choice between old and new. Here’s what the container-first idea could mean for VDI, DaaS, and secure workspace teams, where it could help, and why established platforms remain so valuable.

Key takeaways

  • A container-first endpoint runs a minimal, verified execution layer and receives applications, such as a VDI client, as isolated containers assigned by policy. Session state is discarded after use.
  • Purpose-built Linux endpoint operating systems such as IGEL OS, UniconOS, and RangeeOS remain the proven standard, with read-only system partitions, verified boot, and years of certified client and peripheral support.
  • For VDI and DaaS, the real test is the full user experience: GPU acceleration, video decoding, Teams and Zoom optimization, USB redirection, and smart cards, not just whether the client launches.
  • Statelessness reduces persistent risk, but it doesn’t stop stolen credentials, in-session attacks, or a compromised container supply chain.
  • Hardware sets the ceiling for every architecture. Choose endpoint hardware that can keep pace with your software strategy as it changes.

Dark, glowing illustration of a thin client device carrying blue glass container blocks, with one container arriving on a red light beam, beside the title Container-First Endpoints: Another Path for EUC Innovation.

What is a container-first endpoint?

A container-first endpoint is a device that runs a minimal, verified execution layer instead of a conventional, fully installed operating system. Workloads such as a VDI client arrive as isolated containers according to policy, and runtime state is discarded when the session ends.

The device stops being an installed software environment to maintain. It becomes a delivery mechanism for exactly the functionality a given user or task requires.

Containers themselves are hardly new; they have been a staple of data center and cloud infrastructure for more than a decade. What’s notable is applying them to the endpoint, where purpose-built operating systems have long set the standard.

How do purpose-built Linux endpoint operating systems secure thin clients today?

They remove what attackers depend on: writable system files, local data, local admin rights, and unverified code.

For organizations delivering VDI, DaaS, virtual applications, and secure remote workspaces, the endpoint has one core job: give users a secure, reliable path to centrally hosted resources.

Purpose-built Linux endpoint operating systems have become a popular way to do that job. Platforms such as IGEL OS, UniconOS (formerly eLux, now offered by Citrix), and RangeeOS show how a lightweight OS can cut endpoint complexity while giving IT centralized control over applications, configurations, and user access.

The design principles

The philosophy is well established:

  • Minimize unnecessary software to shrink the attack surface.
  • Restrict local changes so users can’t alter the system.
  • Protect the system with a read-only, immutable OS partition and a verified boot chain.
  • Eliminate local user data, so a lost or stolen device holds nothing of value.
  • Standardize configuration through centralized management.

The result is a predictable environment across a large fleet. When the endpoint’s main task is opening a secure connection to a remote desktop, that predictability is exactly what IT wants.

What leading platforms add

Leading platforms go well beyond restriction. IGEL’s published security architecture for IGEL OS 12, for example, describes:

  • a hardware-rooted chain of trust, from UEFI Secure Boot through the bootloader and kernel to the OS partitions, in which only signed components run and any tampering stops the boot;
  • an encrypted partition for settings and credentials, with keys protected by TPM 2.0;
  • “no-exec” mounting for USB and other removable media, and no local admin rights for users by default; and
  • delta updates applied as atomic commits, with a fallback partition for safe rollback.

UniconOS takes a similar approach: Citrix’s documentation describes a write-protected file system designed to resist viruses and other malware.

In other words, these platforms already deliver much of what “stateless” promises: a restart returns the device to a known-good state.

Why the ecosystem matters

Just as important is compatibility. Established endpoint OS vendors have invested years in certifying VDI and DaaS clients, supporting thousands of peripherals and drivers, and integrating with authentication, unified communications, and management solutions.

Some of that work can’t be replicated quickly. Linux thin clients, for example, typically reach Azure Virtual Desktop and Windows 365 through clients built by Microsoft-approved partners, including IGEL, Dell, HP, 10ZiG, NComputing, Stratodesk, and Unicon.

That broad, tested ecosystem is hard-won, and it’s a big reason these platforms are trusted in demanding environments. At the same time, healthy industries keep exploring new ideas. Container-first architecture is one of them.

How does a container-first, stateless endpoint work?

A container-first endpoint separates the device’s underlying execution layer from the workloads it runs. Instead of running a conventional OS with a fixed set of installed applications, the endpoint receives containerized workloads based on policy and runs each in an isolated environment.

Example: Scylos ZeroCore and Switchboard

One company taking this approach is Scylos, a Nashville-based startup that exhibited at EUC World Amplify 2026 in Milwaukee. According to the company’s launch announcement, its platform has two parts:

  • ZeroCore, a stateless execution layer that runs authorized containerized workloads locally. Scylos describes it as operating-system-free.
  • Switchboard, a single-tenant, cloud-deployed console that centrally manages endpoint configuration and application deployment.

Scylos describes the approach as combining a verified startup environment, locally executed containers, and removal of session state after use. The company launched commercially in late 2025, which places it firmly in the “emerging” category.

What container-first doesn’t remove?

To be clear, containers still need a kernel and supporting runtime. Firmware, drivers, runtime components, and the container supply chain all still need securing. But separating applications from a persistent OS opens up some genuinely new options.

Purpose-built endpoint OS vs. container-first endpoint: what’s the difference?

The biggest difference isn’t the security goal. It’s how applications are packaged, delivered, and updated.

Purpose-built endpoint operating systems start from a fixed software foundation. In leading platforms, that foundation is immutable and read-only, verified at every boot, and holds no user data. The OS remains the center of management: administrators manage OS versions, approved applications, client updates, device settings, and security policies as one environment.

Leading endpoint operating systems are already modular; IGEL OS 12, for instance, runs applications as separately signed packages. A container-first design takes a different route: the execution layer stays minimal, applications arrive as generic containers when needed, and runtime state is discarded when the session ends.

Purpose-built Linux endpoint OS Container-first, stateless endpoint
Foundation Immutable, read-only OS with verified boot Minimal verified execution layer
Applications Signed, modular packages managed with the OS Generic containers delivered by policy
Change management Atomic OS updates with a fallback for rollback; app modules added or removed centrally Update or swap individual workloads
Local data No local user data; a restart returns a clean state Session state discarded after use
Driver and peripheral ecosystem Broad, extensively tested and certified Still developing
Maturity Proven over many years Emerging
Examples IGEL OS, UniconOS, RangeeOS Scylos ZeroCore
Fits best today Production VDI and DaaS fleets that need certified clients and peripherals Pilots where workload flexibility is the priority

This adds a new question to the conversation. Alongside “How do we keep this OS secure?”, architects can also ask, “How little persistent OS state does this endpoint actually need?”

What could container-first endpoints mean for VDI, DaaS, and virtual apps?

Today, a Linux endpoint typically runs Citrix Workspace app, Omnissa Horizon Client, an Azure Virtual Desktop or Windows 365 client, or another connection client, installed and maintained as part of the OS.

In a container-first model, that client could instead be deployed as a managed container. That opens up some interesting scenarios:

  • Role-based assignment. Different devices or users receive different client environments by policy.
  • Fast repurposing. A device used for Citrix access today could serve a different workspace platform tomorrow, without rebuilding its software. Scylos calls this ShapeShifter: a policy-driven change of device persona without a reboot or reimage.
  • Platform transitions. Organizations running multiple EUC platforms, or migrating between providers, could manage the change at the workload level.

The production-readiness gap

A significant gap exists between the concept and a production-ready implementation. VDI clients rely heavily on graphics acceleration, hardware video decoding, audio, webcams, USB redirection, smart cards, and authentication integrations. Each of these adds engineering and compatibility work inside a container.

Unified communications show how much depends on endpoint-side components. Microsoft is moving Teams optimization in virtual desktops to a new media engine, SlimCore, that runs on the endpoint. For Windows endpoints connecting to Azure Virtual Desktop, Windows 365, and Citrix, the older WebRTC-based optimization lost official support on October 1, 2026, and will stop working on April 1, 2027. On Linux endpoints, the WebRTC-based path remains supported for now, and Citrix says it plans a Linux version of the new solution. Any endpoint architecture, container-first or not, needs a credible way to deliver, update, and support media engines like this one. We look at what the Teams VDI changes mean for thin clients in a separate post.

Bottom line: not every VDI or DaaS client can be containerized without trade-offs. The real test is whether the full user experience holds up, not just whether the client launches.

Are stateless endpoints more secure?

They can be, within limits. The strongest security argument for statelessness is simple: what doesn’t persist can’t be tampered with later. If an endpoint reliably returns to a verified baseline after every session, persistent compromise and configuration drift become much harder.

This principle isn’t new to endpoints. Leading purpose-built operating systems already apply it: a read-only system partition, a boot chain that refuses to start if anything has been tampered with, and no local user data mean a restart returns the device to a known-good state. Container-first designs pursue the same goal through a different architecture.

The container world reached a similar conclusion on its own. NIST’s Application Container Security Guide (SP 800-190) recommends running containers on minimal, container-specific host operating systems with read-only file systems, which closely matches the design philosophy purpose-built endpoint operating systems have refined for years.

Returning to a clean state matters most in shared-device settings such as hospitals, financial institutions, call centers, schools, and public-access workstations, where many users touch the same hardware every day.

What statelessness doesn’t solve

Statelessness is not the same as complete security. On its own, it doesn’t address:

  • compromised user credentials,
  • attacks that happen during an active session,
  • malicious or unauthorized workloads, or
  • vulnerabilities in the runtime itself.

Containers also bring their own responsibilities. NIST groups container risk into five areas: images, registries, orchestrators, containers, and the host OS. On an endpoint, that translates into image integrity, registry security, isolation boundaries, and workload authorization.

Bottom line: stateless design is a promising way to reduce and manage endpoint risk, but it’s one layer of a broader security strategy, not a replacement for one. The October 2026 PHP2Shell vulnerabilities showed why. Patching the affected PHP servers was urgent, but the endpoints people use to reach those systems still need their own protections. Our breakdown of the flaws explains why patching the server is only half of endpoint security.

Can containerized delivery add flexibility without sacrificing control?

It can shift the balance, but it trades one kind of operational work for another.

Endpoint computing has always balanced flexibility against standardization. IT wants devices that are easy to manage and hard to compromise. Users and the business keep asking for more applications, protocols, peripherals, and authentication methods.

Purpose-built endpoint operating systems already handle much of this well, thanks to broad client support, extensive peripheral compatibility, and mature management tooling.

Containerized delivery offers a different balance. Rather than updating a shared OS image for every change, administrators could:

  • update or replace individual workloads,
  • assign different configurations to different device groups, and
  • test, stage, or roll back application versions more easily.

The trade-off is real, though. Container lifecycle management, image validation, hardware access, and application compatibility all become critical.

Bottom line: organizations exchange some traditional OS management work for new workload orchestration and security work. Whether that’s a net gain depends on the platform’s maturity and your organization’s needs.

Why does endpoint hardware matter more, not less?

Whatever runs on the endpoint, whether a traditional Linux OS, an immutable platform, or a stateless container layer, the hardware sets the ceiling on what it can deliver.

For VDI and DaaS users, the processor, GPU and hardware decoding, network interfaces, firmware, and physical ports determine whether the device can:

  • drive multiple high-resolution monitors,
  • deliver smooth multimedia and video conferencing, and
  • connect reliably to smart card readers, headsets, scanners, and other enterprise peripherals.

Containerization doesn’t eliminate those requirements. If anything, separating applications from the OS makes consistent, well-supported endpoint hardware more important, especially when workloads need direct access to specialized device capabilities, such as the COM ports and dual LAN connections on an industrial thin client like the TCD i Series.

<!– EDITOR (optional, recommended): add one or two sentences of first-hand experience from ThinClient Direct’s own hardware testing here, e.g. which device capabilities most often decide whether a VDI client performs well in the field. First-hand, non-commodity detail is what Google’s 2026 guidance says AI features favor. Delete this comment if unused. –>

That’s why hardware flexibility and OS choice belong at the center of any endpoint strategy. The best hardware investment can follow your software architecture as it evolves, rather than forcing a refresh every time it changes.

7 questions to ask before evaluating a container-first endpoint

If this approach is on your radar, these questions will separate a promising concept from a production-ready platform:

  1. Client support. Which VDI and DaaS clients do you support today, in which versions, and with which features: multimedia redirection, Teams and Zoom optimization, USB, and smart cards? Does the client vendor support that configuration?
  2. Peripherals. How are webcams, headsets, printers, scanners, and smart card readers passed through to containers?
  3. Graphics and video. Are GPU acceleration and hardware video decoding available to containerized workloads?
  4. Supply chain. How are container images signed, validated, and distributed? Who maintains them, and how quickly do you patch vulnerabilities?
  5. Session boundaries. What exactly is discarded after a session, and what, if anything, persists?
  6. Operations. How does management compare with your current tooling for rollouts, rollbacks, and monitoring?
  7. Hardware. Which devices are certified, and will your existing fleet run it?

Will container-first endpoints replace purpose-built thin client operating systems?

No. The reality isn’t that black-and-white.

These platforms have matured over many years. Their vendors do the difficult, ongoing work of keeping an immutable, verified OS secure while remaining compatible with a vast range of drivers, peripherals, clients, and partner solutions. That predictability and ecosystem breadth are exactly what many organizations need, and a controlled, lightweight Linux OS remains an excellent choice.

Container-first, stateless technologies offer another path for innovation, particularly in how applications are packaged, delivered, and moved between platforms. Exploring alternative architectures pushes the industry forward, and established platforms are well placed to adopt ideas that prove themselves, such as greater application isolation, immutable components, and container-based delivery. Customers benefit most when both approaches keep raising the bar.

What should an endpoint OS actually do?

For most of EUC’s history, the debate has centered on where applications and desktops run: on-premises VDI, cloud desktops, DaaS, app virtualization, or secure browsers. The endpoint itself has stayed architecturally familiar: an operating system running a client.

Container-first approaches add a new angle. The future endpoint may be defined less by the OS it runs and more by its ability to securely execute the right workloads, connect to the right resources, and return to a trusted state.

Established endpoint operating systems will continue to play a central role. New approaches widen the set of ideas the whole industry can draw on.

As EUC evolves, the most valuable endpoint will let organizations choose how applications and workspaces are delivered, without replacing hardware every time the software architecture changes.

Frequently asked questions

Is a container-first endpoint really “operating-system-free”?

Not in an absolute sense. Containers still need a kernel, drivers, firmware, and a runtime, and each needs to be secured. When a vendor describes a design as operating-system-free, the useful question is what’s absent: typically a conventional, general-purpose OS that persists between sessions and has to be patched as one environment.

Can Citrix Workspace app or Omnissa Horizon Client run in a container?

In principle, yes. In production, it depends on whether graphics acceleration, video decoding, USB and smart card redirection, authentication, and unified communications optimization all work inside the container, and whether the client vendor supports that configuration. Ask for a feature-by-feature support matrix before you pilot.

Is a stateless endpoint the same as non-persistent VDI?

No. Non-persistent VDI resets the virtual desktop that runs in the data center or cloud. A stateless endpoint resets the physical device’s local runtime. The two complement each other, and an organization can use both.

Which organizations benefit most from stateless endpoints?

Shared-device environments benefit most: hospitals, financial institutions, call centers, schools, and public-access workstations. When many users touch the same hardware every day, returning to a clean state after each session limits what one user can leave behind for the next.

Should we replace our current thin client operating system?

For most production fleets, not today. Purpose-built Linux endpoint operating systems remain proven, certified, and broadly compatible. If container-first endpoints interest you, run a scoped pilot against the seven questions above, and make sure your hardware can support either path.

About ThinClient Direct

ThinClient Direct tracks emerging endpoint technologies and operating system architectures across the end-user computing ecosystem. We focus on flexible, purpose-built hardware that supports your preferred VDI, DaaS, and secure workspace environments today and adapts as they change. Talk to our team about finding the right endpoint hardware for your strategy, or request a free 45-day trial device to test in your own environment.

Want to see how a thin client behaves in your environment?

We’ll ship you a Thin Client Direct endpoint to use free for 45 days with your real users and real
workloads in Citrix, Omnissa, Azure Virtual Desktop, or Windows 365. No obligation. No forced
platform choice.

Request a 45-Day Trial Device

post contents