VIEApps NGX is an open-source, application-level communication runtime platform for distributed systems.
Built on .NET, it provides a high-performance, message-driven foundation for coordinating, scaling, and operating distributed services.
Unlike traditional microservices frameworks that focus on service implementation, VIEApps NGX focuses on runtime-level communication, routing, and execution orchestration.
It separates service logic from system operation, allowing distributed systems to scale, adapt, and evolve without changing core architecture.
Runtime-Centric Architecture
VIEApps NGX is not a monolithic system.
It is a structured runtime ecosystem composed of:
- foundational communication and service abstraction layers
- a distributed routing and execution runtime
- independently deployable microservices operating on top of that runtime
At its core, the system is defined not by individual services, but by how services communicate, coordinate, and execute across the system.
Core Components
1. VIEApps.Services.Abstractions
Provides shared contracts, interfaces, DTOs, and message exchange patterns.
This layer defines a consistent communication model across all services, ensuring decoupled and interoperable service interactions.
2. VIEApps.Services.Base
The foundational layer for all services.
It standardizes service processing models, lifecycle management, logging, and cross-cutting infrastructure concerns.
3. VIEApps.Services.Base.Http
An extension layer for HTTP-based services.
It enables external API exposure while preserving the internal message-driven processing model of the system.
Within the HTTP layer, VIEApps NGX provides built-in communication adapters:
- REST API adapter for standard request-response interactions
- WebSocket API adapter for real-time, bidirectional communication
- Server-Sent Events (SSE) as a fallback mechanism when WebSocket is not available or restricted
These adapters are integrated into the same runtime model, allowing services to expose different communication patterns without changing internal logic.
Real-time communication is preserved across adapters, with graceful degradation handled at the transport layer, without affecting the core runtime execution model.
In addition, all incoming requests passing through the HTTP layer are subject to runtime-level admission control (Router RPC Gate).
This mechanism dynamically regulates concurrent execution and request flow under load, ensuring that the system remains stable and responsive even during extreme traffic spikes, without relying solely on infrastructure-level scaling.
4. VIEApps.Services.APIGateway
(Communication Runtime Core)
The API Gateway is the central communication runtime of the system.
It is not a traditional reverse proxy.
It functions as a distributed service bus and RPC routing runtime, responsible for:
- message routing
- service coordination
- load distribution
- execution orchestration
At its core, the runtime is built on WAMP (Web Application Messaging Protocol), enabling message-driven RPC and dynamic routing across distributed nodes.
Routed RPC Execution Model
The system is built around a Routed RPC model, where:
- service invocation is message-driven
- execution is dynamically routed across nodes
- service instances are fully decoupled from callers
Incoming requests are not bound to specific service instances.
Instead, they are routed in real time to available nodes, enabling:
- load-balanced execution across distributed environments
- elastic horizontal scaling without architectural changes
- high availability through runtime-level coordination
This model removes direct coupling between services and replaces it with a runtime-managed execution layer.
Reactive Execution Engine
The runtime execution model is built on ReactiveX, enabling:
- asynchronous, event-driven execution
- non-blocking distributed pipelines
- high-throughput message processing
This allows the system to handle large volumes of concurrent operations while maintaining responsiveness and stability.
The Runtime as the System’s Source of Truth
In VIEApps NGX, the communication runtime becomes the central point of truth for the system:
- routing decisions
- load balancing
- service coordination
- execution flow
This replaces many traditional infrastructure concerns — such as load balancers, service mesh layers, and RPC frameworks — with a unified runtime layer.
Infrastructure Capabilities
Real-Time Communication
WebSocket and event-driven messaging are built into the runtime.
Real-time data exchange is a natural outcome of the communication model, not an add-on feature.
Multi-Database Flexibility
The platform supports both SQL and NoSQL systems simultaneously.
It enables distributed data strategies and synchronization models suitable for complex enterprise environments.
Advanced Caching System
Integrated with VIEApps.Components.Caching, the platform provides:
- L1 in-memory caching
- L2 distributed caching (Redis, Memcached)
This layered caching strategy improves performance and reduces database load under high traffic.
Runtime-Aware Edge Control
VIEApps NGX integrates tightly with CDN layers to extend runtime control beyond the application layer.
Instead of relying on time-based expiration or manual cache purging, the system performs:
- precision cache invalidation at the URL level
- triggered directly by business logic changes
- executed in real time through the runtime
This ensures that:
- only affected content is refreshed
- cache remains highly effective under load
- unnecessary traffic spikes caused by broad cache invalidation are avoided
Cached content is treated as immutable at the edge and only updated when explicitly invalidated by runtime-driven logic.
By aligning edge caching behavior with runtime execution, VIEApps NGX maintains system stability not only at the service layer, but also at the network edge.
The system operates across multiple caching layers — edge CDN and internal runtime cache — ensuring both low latency and efficient load distribution.
Even under transient failures, cached responses can be safely served to maintain system availability.
Edge cache is not managed by time. It is controlled by runtime.
Service Ecosystem
VIEApps NGX includes a set of independently deployable services, such as:
- Portals (CMS management)
- Users & Identity
- Files
- OTP & Security services
- IP Location services
These services demonstrate how full enterprise systems can be built on top of the runtime while remaining modular and scalable.
Open-Source Philosophy
VIEApps NGX is open-source software built on the principle of freedom:
- freedom to inspect
- freedom to extend
- freedom to integrate
Free as in freedom — not free of charge.
Summary
VIEApps NGX is not a framework for building services.
It is a runtime platform for operating distributed systems.
By shifting the focus from service implementation to communication and execution, it enables systems to scale, adapt, and evolve without being constrained by infrastructure or tightly coupled architectures.