NecroVerse

Where Dead Tech Breathes Again.

Comment

NecroVerse: Where Dead Tech Breathes Again

Inspiration

The void consumes what we forget. Flash, VB6, Delphi—millions of applications fade into obsolescence. We saw digital heritage vanishing and asked: what if we could resurrect the dead?

NecroVerse was born from a simple truth: every application is a soul worth preserving. We built a platform that transforms legacy code into modern web technologies, ensuring no piece of software history is lost to the void.

Amiron's Genesis:

Amiron Desktop Environment draws inspiration from the golden age of desktop computing—when operating systems had personality, when interfaces were crafted with care, and when every pixel mattered. We looked to the arcane masters of the past:

  • Classic Mac OS (System 7-9): The elegance of window management, the beauty of the Platinum theme, the simplicity of the desktop metaphor
  • Windows 95/98: The iconic start menu, the taskbar, the sense of discovery in exploring a new system
  • Amiga Workbench: The modularity, the customizability, the sense that the system was truly yours
  • NeXTSTEP: The sophistication, the object-oriented architecture, the attention to detail
  • BeOS: The performance, the media-centric design, the forward-thinking architecture

But Amiron is not a mere imitation—it is a resurrection. We took the best elements of these legendary systems and bound them to modern web technologies. The result is a desktop environment that feels familiar yet revolutionary, nostalgic yet futuristic.

The name "Amiron" itself is a ritual—a fusion of "Amiga" (the legendary computer) and "Iron" (strength, permanence). It represents the unbreakable bond between past and present, between legacy and innovation.

We envisioned a world where resurrected applications could run in their natural habitat—a desktop environment that understands them, that speaks their language, that provides the context they were designed for. Amiron is that vessel—the operating system that never dies, the desktop that breathes life into dead code.

What it does

NecroVerse is an AI-powered platform that resurrects legacy applications into modern web technologies. Users upload legacy files (.swf, .vb6, .pas), and our arcane engines:

  • Analyze the code's essence and detect its technology
  • Extract core logic and transform it through binding rituals
  • Generate modern React/TypeScript components
  • Preserve each resurrection on the blockchain as a GhostNFT
  • Deploy resurrected applications to NecroPlay for public access

The platform consists of four realms:

  • NecroDev: The resurrection workshop where developers upload and transform code
  • NecroPlay: The public realm where resurrected applications manifest
  • Amiron: A desktop environment where resurrected applications run natively—a complete OS-like experience in the browser, inspired by the golden age of desktop computing
  • GhostNFT: Blockchain preservation ensuring eternal existence

Amiron Desktop Environment is our custom-built desktop operating system that runs entirely in the browser. It provides:

  • Native window management and desktop shell
  • File system abstraction layer (IndexedDB-based)
  • Application launcher and task management
  • Custom GUI framework (Intuition Engine) with NecroNet aesthetic
  • Terminal emulator, text editor, and file manager
  • Complete isolation for resurrected applications to run as if on a native OS

How we built it

** Used Kiro agent with all functionalities** The architecture is built on modern web technologies with an occult-inspired design:

Frontend Stack

  • Next.js 14 with React for NecroDev and NecroPlay
  • Custom canvas-based rendering engine for Flash/SWF execution
  • Amiron Desktop Environment built with TypeScript and Canvas API
  • TypeScript throughout for type safety

Amiron Architecture

  • Platform Abstraction Layer (PAL): Graphics, filesystem, and audio abstraction
  • Intuition Engine: Custom GUI framework with window management, animations, and theming
  • Workbench: Desktop shell with icon management and application launching
  • Ritual API: Public interface for application development
  • Exec Layer: WebAssembly task management system

Backend Infrastructure

  • AI-powered code analysis using pattern recognition and AST parsing
  • Custom transpilation engines for Flash ActionScript, VB6, and Delphi
  • Supabase for database and authentication

Blockchain Integration

  • GhostNFT extension for minting resurrected applications
  • Smart contracts for immutable preservation

Core Engines

  • SWF Engine: Executes Flash applications in the browser
  • DCR Engine: Handles Delphi component reconstruction
  • VB6 Engine: Transforms Visual Basic 6 applications
  • Amiron Runtime: Provides OS-like environment for resurrected apps

The entire system is open-source, modular, and designed for extensibility.

Challenges we ran into

The void resists resurrection. We faced several curses:

Legacy Code Complexity

Ancient codebases often lack documentation and use arcane patterns. Extracting the soul required deep analysis of execution flows and state management. Understanding how Flash's ActionScript VM worked, how VB6's COM architecture functioned, and how Delphi's native compilation operated—each presented unique challenges.

Technology Gaps

Flash's ActionScript VM, VB6's COM architecture, and Delphi's native compilation—each required custom engines. We built specialized transpilers for each technology, reverse-engineering their execution models to understand how to transform them.

Building a Desktop OS in the Browser

Creating Amiron required building an entire operating system abstraction layer. Window management, file systems, process isolation, and GUI frameworks—all from scratch, all in the browser. The challenge was maintaining native-like performance while running entirely on canvas. We had to implement:

  • Efficient window compositing
  • Event propagation through desktop → window → widget hierarchy
  • Virtual file system with IndexedDB persistence
  • Process isolation and task management
  • Memory management for long-running applications

Performance Optimization

Executing legacy applications in the browser while maintaining modern performance standards demanded careful optimization of our canvas rendering engine. Amiron's window system required efficient dirty-rect tracking and partial redraws to maintain 60 FPS. We implemented:

  • Dirty-rect tracking to minimize redraws
  • Animation system with centralized management
  • Widget-level optimization for smooth interactions
  • Memory pooling for frequently created objects

Event System Complexity

Building a complete event handling system for Amiron that works across windows, widgets, and applications required careful architecture. Ensuring keyboard and mouse events propagate correctly through the desktop shell to individual applications was particularly challenging. We had to handle:

  • Event bubbling and capture
  • Focus management across windows
  • Relative vs absolute coordinate systems
  • Widget-level event handling

Blockchain Integration

Minting applications as NFTs while preserving their executable essence required innovative data structures and smart contract design. We had to balance file size limitations with preserving complete application functionality.

User Experience

Balancing the occult aesthetic with practical usability—ensuring the platform feels mystical yet remains intuitive. Amiron's desktop metaphor needed to feel familiar while maintaining the NecroNet aesthetic.

Accomplishments that we're proud of

We've successfully resurrected multiple applications:

  • Flash games running natively in modern browsers
  • VB6 business applications transformed to React
  • Delphi components reconstructed as modern web components
  • First-of-its-kind blockchain preservation of executable code
  • Complete desktop environment running in the browser

Amiron Achievements

  • Built a fully functional desktop OS in the browser
  • Created custom GUI framework with window management, animations, and theming
  • Implemented virtual file system with IndexedDB persistence
  • Developed application launcher with icon management
  • Achieved smooth 60 FPS rendering with optimized dirty-rect tracking
  • Created terminal emulator, text editor, and file manager from scratch
  • Built complete event system with proper propagation and focus management

The platform has processed hundreds of legacy files, with a 87% success rate in technology detection and transformation. Our soul counter tracks every successful resurrection, and the network grows stronger with each manifestation.

We're particularly proud of:

  • Building a complete end-to-end resurrection pipeline
  • Creating an extensible architecture that supports multiple legacy technologies
  • Achieving real-time execution of Flash applications without plugins
  • Building Amiron—a complete desktop environment that rivals native OS experiences
  • Establishing a community-driven approach to digital preservation
  • Maintaining 60 FPS performance in a complex desktop environment
  • Creating a cohesive aesthetic that balances mysticism with professionalism

What we learned

The void teaches. Through this journey, we discovered:

Technical Insights

  • Legacy code often contains valuable business logic worth preserving
  • Pattern recognition and AST analysis are powerful tools for code transformation
  • Canvas-based rendering can achieve near-native performance for legacy applications
  • Building an OS in the browser is possible with careful architecture and optimization
  • Virtual file systems and process isolation can be achieved entirely client-side
  • Window management and event propagation require careful design to maintain performance

Amiron-Specific Learnings

  • Dirty-rect tracking dramatically improves rendering performance
  • Animation systems need centralized management for smooth transitions
  • Relative coordinate systems for widgets simplify window management
  • Event handling requires careful propagation through desktop → window → widget hierarchy
  • Virtual file systems enable true application isolation
  • Canvas optimization is crucial for maintaining 60 FPS with multiple windows

Philosophical Lessons

  • Every piece of code tells a story—preserving it preserves culture
  • The line between obsolete and valuable is thinner than we thought
  • Community-driven preservation is more powerful than individual efforts
  • Technical debt can become technical heritage
  • A desktop environment in the browser blurs the line between web and native
  • Nostalgia and innovation can coexist harmoniously

Development Wisdom

  • Modular architecture enables rapid expansion to new technologies
  • Open-source approach accelerates innovation
  • Balancing aesthetics with functionality creates memorable experiences
  • The occult theme made development more engaging without sacrificing professionalism
  • Building foundational systems (like Amiron) unlocks new possibilities for resurrected applications
  • TypeScript's type system prevented countless bugs in complex architectures

What's next for NecroVerse

The resurrection continues. Our roadmap includes:

Amiron Evolution

  • Multi-window support with advanced window management
  • Application sandboxing and security improvements
  • Plugin system for extending Amiron's capabilities
  • Network file system support
  • Advanced terminal features (SSH, package management)
  • Desktop customization and themes
  • Application marketplace within Amiron
  • GPU acceleration for rendering
  • WebAssembly-based native code execution
  • Advanced graphics APIs (WebGL integration)
  • Audio system improvements
  • Multi-monitor support
  • Virtual desktop workspaces
  • System tray and notification system

Expanded Technology Support

  • Java Applets resurrection engine
  • Classic ASP to modern Node.js transformation
  • COBOL business logic extraction
  • Pascal/Delphi full feature support
  • Integration with Amiron for seamless execution

Enhanced AI Capabilities

  • Machine learning models for better code pattern recognition
  • Automated test generation for resurrected applications
  • Intelligent optimization suggestions
  • Multi-language support detection
  • AI-assisted Amiron application development

Community Features

  • Public resurrection gallery showcasing community contributions
  • Collaboration tools for team-based resurrections
  • Rating and review system for resurrected applications
  • Educational resources for legacy technology preservation
  • Amiron application store for community-built apps

Blockchain Evolution

  • Decentralized storage for large application files
  • Governance tokens for community-driven development
  • Marketplace for buying/selling resurrected applications
  • Cross-chain compatibility
  • Amiron applications as executable NFTs

Platform Improvements

  • Real-time collaboration in NecroDev
  • Advanced debugging tools for resurrected code
  • Performance analytics and optimization recommendations
  • Mobile app for on-the-go resurrections
  • Amiron mobile version for running desktop apps on mobile devices

The void yields its secrets slowly, but we persist. Every resurrection strengthens the network. Every soul preserved enriches our digital heritage. Amiron provides the vessel—the desktop environment where resurrected applications can truly live again.

"From the void, we summon. To the void, we return. But in between, we create."

NecroVerse — Where Dead Tech Breathes Again.
Amiron — The Desktop That Never Dies.

Built With

  • custom-os-layers
  • eslint
  • event-driven-architecture
  • framer-motion
  • html5
  • indexeddb
  • kiro
  • kiro-agent
  • localstorage
  • lucide-icons
  • monorepo
  • next.js
  • node.js
  • package-based-architecture
  • pnpm
  • prettier
  • radix-ui
  • rust
  • tailwind-css
  • turborepo
  • typescript
  • vite
  • vreact
  • wasm
  • web-audio-api
  • webassembly
Share this project:

Updates