icOS - Decentralized Cloud Operating System

Project Status: In Development (Alpha)
Technology Stack: Svelte 5, Internet Computer Protocol (ICP), Motoko, CanDB, TypeScript, TailwindCSS, Podman
Repository: ~/repos/ic-os
Architecture: Multi-canister CanDB backend with Podman-based containerized development

Links

dApp source

Overview

icOS (IC-OS-Interface) is a decentralized cloud operating system that turns any modern browser into a full desktop environment running on the Internet Computer. Inspired by Samsung DeX and Nextcloud but rebuilt for Web3, icOS combines familiar OS concepts, windows, apps, files, and widgets, with blockchain-backed data sovereignty and cross-device synchronization.

All core state, user profiles, app data, and files, is stored in Motoko canisters backed by CanDB, giving icOS horizontally scalable storage without relying on centralized servers or traditional cloud providers.

Core Applications

The icOS interface centers around a growing suite of built-in apps:

• Terminal – Glass-styled terminal interface for commands, scripts, and future LLM-assisted workflows.
• File Browser – Upload, organize, and preview files with thumbnails, metadata, and on-demand expandable storage via CanDB.
• Messenger – Principal-to-principal messaging on the Internet Computer with a modern chat UI.
• Password Manager – Client-side encrypted credential storage backed by a dedicated PasswordManager canister.
• Calendar & Bookmarks – Scheduling and AI-assisted bookmark management tailored to IC resources.
• Widget-based Homescreen – Modular dashboard with weather, crypto tickers, system metrics, quick notes, and more.

The goal is to give users a full daily-driver environment, productivity, communication, and entertainment, entirely in the browser and entirely on-chain.

Customization & Configurability

icOS is designed to feel like your machine, not a fixed dashboard.

Homescreen & widgets

• Grid-based layout – Apps and widgets are arranged on a configurable grid, with support for larger 2×2 “tile” widgets and multiple screens/workspaces.
• Widget catalog – Weather, crypto tickers, activity rings, quick notes, audio controls, metrics panels, and more can be pinned to the homescreen.
• Per-user layout – Layout, screen count, and widget configuration are stored in your user config on the UserService canister, so your desktop follows you between devices.
• Import / export instance – From the Settings app you can export your icOS instance (layout + config) to a file, wipe an instance, and import it again - useful for backups, device migration, or sharing setups.

Wallpaper system: images, GIFs, and shaders

The wallpaper system combines traditional backgrounds with procedural shader art:

• Two wallpaper modes – Choose between image-based wallpapers (including GIFs) and GPU-powered shader wallpapers sourced from a curated registry of 3D/GLSL scenes.
• User-driven backgrounds – Authenticated users can load wallpapers from their own on-chain storage; anonymous sessions fall back to demo wallpapers so the OS still feels alive.
• Auto-rotate with timer – A global wallpaper timer (managed by the wallpaper.store and exposed in Settings) can automatically rotate backgrounds on a schedule. You can:
  • Toggle auto-rotate on or off.
  • Set the rotation interval in human-friendly units (seconds, minutes, hours, or days), which the app translates into a precise interval under the hood.
• Smart shader selection – When shader mode is active, icOS picks from wallpapers that are tagged as suitable (procedural/abstract/SDF, non-interactive, non-particle-heavy) to avoid overly intense or distracting backgrounds.
• Smooth transitions & persistence – Wallpaper preferences are kept in both your on-chain user config and local storage, and are applied with smooth transitions instead of hard cuts on refresh.

Architecture & Tech Stack

Multi-canister backend

icOS uses a multi-canister Motoko backend orchestrated by an Index canister:

• IndexCanister – Entry point and orchestrator; manages partition creation and auto-scaling.
• AppService – Stores app-level data and metadata using CanDB.
• UserService – Manages user profiles, settings, and layout configurations.
• PasswordManager – Handles encrypted vault data for the password manager.
• Frontend canister – Serves the Svelte application and static assets.

File and application data is stored in CanDB partitions, allowing icOS to auto-scale storage: as partitions reach configured limits, the IndexCanister and CyclesManager spawn new service canisters and wire them into the system without downtime.

		icOS Canister Architecture
┌───────────────────────┐
│     IndexCanister     │  (Orchestrator)
│  - Routing & auth     │  - Partition management
│  - Auto-scaling hooks │  - Cycle requests/top-ups
└───────────┬───────────┘
            │
            ├──────────────────────────────┬──────────────────────────────┬──────────────────────────────┐
            │                              │                              │                              │
            ▼                              ▼                              ▼                              │
┌───────────────────────┐       ┌───────────────────────┐       ┌───────────────────────┐               │
│     AppService        │       │    UserService        │       │  PasswordManager      │               │
│     (Partition)       │       │    (Partition)        │       │    (Partition)        │               │
└───────────────────────┘       └───────────────────────┘       └───────────────────────┘               │
┌───────────────────────┐       ┌───────────────────────┐       ┌───────────────────────┐               │
│     AppService        │       │    UserService        │       │  PasswordManager      │               │
│     Instance 2        │       │    Instance 2         │       │    Instance 2         │               │
└───────────────────────┘       └───────────────────────┘       └───────────────────────┘               │
       ⋮                            ⋮                                ⋮                                │
 (Auto-scaled via CanDB)    (Auto-scaled via CanDB)         (Auto-scaled via CanDB)                    │
                                                                                                       │
                        ┌───────────────────────────────┐                                             │
                        │         Cycle Flow            │                                             │
                        └───────────────────────────────┘                                             │
┌───────────────────────┐                           ┌───────────────────────┐
│  Service Partitions   │── Cycle request ────────►│     IndexCanister     │
│ (App/User/Password)   │◄─ Top-up / new canister ─│   + CyclesManager     │
└───────────────────────┘                           └───────────────────────┘
     (Consume cycles)                                   (Allocates & routes
                                                         cycles, spawns new
                                                            service cans)
	

Frontend & UX

• Svelte 5 + SvelteKit for the reactive desktop-like UI and routing.
• TypeScript and shared services/stores under src/frontend/src/lib/.
• TailwindCSS + Shadcn UI for a glassmorphism-inspired design system with reusable components.
• Vite for fast development builds and hot module reloading.

Authentication & Data Flow

• Internet Identity for passwordless authentication and principal management.
• Svelte stores maintain auth state on the client and pass principals into canister calls.
• All sensitive data (e.g., passwords) is encrypted client-side before being sent to the PasswordManager canister.

Request flow (high level)

		icOS Request Flow
┌───────────────────┐         HTTPS          ┌───────────────────────┐
│     Browser       │ ─────────────────────► │   Frontend canister   │
│   (icOS UI)       │ ◄───────────────────── │ (SvelteKit assets)    │
└─────────┬─────────┘                        └──────────┬────────────┘
          │   Candid / agent calls                      │
          │                                             │
          │                                 ┌───────────▼───────────┐
          │                                 │     IndexCanister     │
          │                                 │  Routing & scaling    │
          │                                 └───────────┬───────────┘
          │                                             │
          │                 ┌───────────────────────────┼───────────────────────────┐
          │                 │                           │                           │
          ▼                 ▼                           ▼                           ▼
┌───────────────────┐ ┌───────────────────┐     ┌───────────────────┐     ┌───────────────────┐
│   AppService      │ │   UserService     │     │  PasswordManager  │     │  Other partitions │
│   (App data)      │ │   (Profiles & UI) │     │  (Vault data)     │     │  (future)         │
└───────────────────┘ └───────────────────┘     └───────────────────┘     └───────────────────┘
	

Development & Deployment

icOS is designed to be developed and deployed via containerized workflows:

• Podman-based environment with rootless containers and no background daemon.

• One-command deployment script:

  		./scripts/podman-deploy
  	

  which can spin up frontend, backend canisters (Index/App/User/PasswordManager), and Internet Identity in a single step.

• Support for multiple environments:

  		./scripts/podman-deploy --env local   # local dev
  ./scripts/podman-deploy --env staging # staging
  ./scripts/podman-deploy --env ic      # Internet Computer mainnet
  	

• Additional Podman helpers in podman/ (e.g., podman-manager.sh, quick-start.sh) provide commands to build images, start/stop containers, tail logs, and exec into the dev environment.

For non-containerized flows, standard npm/dfx scripts are available for running the frontend, generating declarations, and deploying canisters from a local machine.

Development Status & Roadmap

icOS is an active, work-in-progress flagship dApp in the DappJak Labs ecosystem. The current focus is on:

• Solidifying the glass-themed desktop environment and widget-based homescreen.
• Hardening the core app suite (terminal, file browser, messenger, password manager).
• Improving Podman-based workflows for local/staging/mainnet deployments.

Planned next steps, as outlined in the technical plan, include:

• Expanding the productivity suite (notes, tasks, richer calendar tooling).
• Deepening AI integrations across apps (assistant, bookmarks, terminal).
• Opening the platform as a third-party app framework and SDK.
• Tightening IC Web3 integrations (wallet UX, DeFi dashboards, DAO tooling).

Long term, icOS aims to feel like a full personal computing environment that lives entirely on the Internet Computer, portable across devices, user-sovereign by design, and extendable by both the core team and external developers.