Ship #1

@anuththara on My WebOS - AstraOS · about 1 month ago

AstraOS is officially shipped

AstraOS is now a fully working browser-based desktop environment that simulates a modern operating system experience directly inside the browser.

It is no longer a prototype or UI demo - it’s a functional system with windows, apps, persistence, and a structured desktop environment

What’s included
Desktop environment
Responsive desktop workspace with icon grid system
Wallpaper support and adaptive scaling
Context menu interactions
Consistent layout behavior across screen sizes

Window management
Draggable, resizable windows
Minimize, maximize, and close controls
Multi-window support with proper focus handling
Z-index management for active windows
Window restore and centering logic

Built-in applications
Notes app with persistent storage
Calculator with working expression engine
File explorer for navigating system structure
Settings application for customization

Dock and system navigation
Application dock with launch and running state indicators
Global menu bar with live clock
Smooth application switching and lifecycle handling

Persistence layer
User preferences stored locally
Application state persistence across sessions
Desktop layout saved and restored automatically
Local storage integration for continuity

Design system
Glassmorphism-based UI styling
Blur and depth layering effects
Smooth transitions and animations
Consistent component-driven layout system

Architecture
Modular component structure
Event-driven interaction system
Reusable UI primitives
Optimized rendering behavior for responsiveness
What AstraOS is

AstraOS is an experiment in turning the browser into a usable operating system layer — combining application lifecycle management, persistent state, and desktop-style interaction patterns into one unified interface.

Try it, break it, push it

This is not a finished product. It is a working system designed to evolve.

Use it as a workspace, stress test the interactions, and explore where it breaks.

Feedback that helps:

What feels slow or unnecessary
What apps are missing
What would make this replace a real desktop workflow

If it’s useful, it stays. If it’s not, it gets rebuilt.

2 devlogs
5h
WebOS 1

Try project → See source code →

Open comments for this post

@anuththara on My WebOS - AstraOS · about 1 month ago

1h 54m 30s logged

DEV LOG FINAL - ASTRAOS PLATFORM INTEGRATION

Overview

AstraOS has evolved into a browser-based operating system simulation that recreates a modern desktop experience with modular applications, persistent storage, and interactive system components.

Implemented Features

Desktop Environment

Responsive desktop workspace
Dynamic icon grid system
Wallpaper support
Context menus
Adaptive scaling

Window Management

Draggable windows
Minimize, maximize and close controls
Active window prioritization
Z-index management
Multi-window support
Window restoration and centering

Dock & Menu Bar

Application launcher dock
Running application indicators
Hover animations
Real-time clock
Global system navigation

Applications

Notes application with persistent storage
Functional calculator engine
Interactive file explorer
Settings application

Persistence Layer

User preferences storage
Desktop layout persistence
Application state persistence
Local storage integration

Design System

Glassmorphism effects
Blur surfaces
Dynamic shadows
Smooth animations
Responsive layouts
Unified visual consistency

Architecture Improvements

Modular component structure
Event-driven interactions
Reusable UI components
Optimized rendering pipelines

Summary

AstraOS is now a fully interactive browser-based desktop environment that combines operating system concepts, application lifecycle management, persistent data handling, and modern UI engineering into a cohesive web platform.

Open comments for this post

@anuththara on My WebOS - AstraOS · about 2 months ago

2h 53m 36s logged

DEV LOG 01 - ASTRAOS INITIAL SYSTEM ARCHITECTURE BOOTSTRAP

Overview

AstraOS is a browser-based desktop operating system simulation inspired by macOS interaction patterns. This initial phase focuses on establishing core UI infrastructure, deterministic window management, and modular application containers inside a single-page web runtime.

The primary goal is to create a stable foundation for a scalable OS-like environment with persistent state handling and structured UI orchestration.

Core System Architecture

Desktop Shell Layer

Implemented base desktop rendering system using DOM-based layout structure
Established icon grid system for desktop applications and folders
Configured dock and menu bar positioning framework
Introduced initial spacing and alignment rules for UI consistency
Defined viewport-based scaling for responsive desktop rendering

Window Management System

Implemented draggable window containers using pointer-event interaction model
Introduced window lifecycle handling (create, focus, minimize, maximize, close)
Centered window launch logic based on viewport calculations
Added basic z-index stacking system for active window prioritization
Defined initial window state model (normal, minimized, maximized)

Dock System

Built application launcher registry mapped to dock UI elements
Enabled app instantiation via dock click events
Added hover interaction states for dock icons
Introduced basic runtime tracking for active applications

Menu Bar System

Implemented persistent top-level system bar
Added basic clock display module (initial implementation)
Reserved integration points for system indicators:
- Network status
- Battery state
- System settings routing

Application Layer

Initial applications implemented as isolated UI modules:

Notes: localStorage-based text persistence prototype
Calculator: UI scaffold with incomplete computation binding
File Explorer: static interface without filesystem backend
Settings: configuration UI skeleton without full state linkage

These apps currently function as independent UI shells awaiting central state integration.

Persistence Layer

Implemented localStorage-based persistence strategy
Defined early schema for:
- User preferences
- Desktop layout state
- Application metadata
Initial groundwork for virtual filesystem simulation

Design System

Established macOS-inspired visual language (rounded surfaces, depth shadows, blur effects)
Defined spacing grid for desktop icon placement
Implemented window styling primitives
Added basic transition timing system for UI animations

System Limitations

No centralized state manager implemented yet
Window resizing not fully supported
No multitasking scheduler or process isolation layer
Missing system-level integrations (battery, network, audio)
Menu clock not synchronized with real-time API
No virtual filesystem fully implemented

Next Objectives

Implement full window resize and transform system
Build global state manager (event-driven architecture)
Complete Notes and Calculator logic engines
Introduce virtual filesystem layer (VFS abstraction)
Improve dock animations and runtime process tracking
Add system API integrations (battery, network, audio)
Begin Safari rendering engine stabilization

Summary

This phase establishes the foundational UI and interaction architecture of AstraOS. The system is currently a structured desktop shell with modular applications and persistent state groundwork. Future development will transition toward full OS-like behavior with real-time system integration and improved runtime consistency.