VIEApps NGX is an open-source, application-level communication runtime platform for distributed systems.
Built on .NET, it provides a message-driven foundation for coordinating, routing, and executing distributed services at scale.
Unlike traditional microservices frameworks that focus on service implementation, VIEApps NGX focuses on runtime-level communication, routing, and execution orchestration.
Runtime-Centric Architecture
VIEApps NGX separates:
- service logic (business implementation)
- system operation (communication, routing, execution)
This allows distributed systems to scale and evolve without modifying core service logic.
The system is structured as a runtime ecosystem composed of:
- communication abstractions
- a distributed routing and execution runtime
- independently deployable microservices
Communication Runtime Core
At the center of the system is a communication runtime (implemented via the API Gateway).
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
The runtime is built on WAMP (Web Application Messaging Protocol), enabling message-driven RPC and dynamic routing across nodes.
Routed RPC Execution Model
VIEApps NGX is built around a Routed RPC model:
- service invocation is message-driven
- execution is dynamically routed across nodes
- callers are fully decoupled from service instances
Requests are routed in real time to available nodes, enabling:
- load-balanced execution
- elastic horizontal scaling without architectural changes
- high availability through runtime-level coordination
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 provides efficient handling of high concurrency without thread-blocking bottlenecks.
HTTP Layer as Communication Adapter
HTTP is treated as an external adapter layer, not the core communication mechanism.
VIEApps NGX provides:
- REST API adapter (request-response)
- WebSocket adapter (bidirectional real-time)
- SSE fallback when WebSocket is unavailable
All adapters map into the same internal message-driven runtime, preserving execution consistency regardless of transport.
Runtime-Level Admission Control
All incoming requests are subject to runtime-level admission control (Router RPC Gate):
- dynamically regulates concurrency
- controls request flow under load
- prevents overload and cascading failures
This ensures system stability under extreme traffic spikes, without relying solely on infrastructure-level scaling.
Runtime as the Source of Truth
The communication runtime becomes the system’s central control layer:
- routing decisions
- load balancing
- execution flow
- service coordination
This reduces reliance on:
- service mesh
- external load balancers
- separate RPC layers
Runtime-Aware Edge Control
VIEApps NGX extends runtime control to the CDN layer through precision cache invalidation.
Cache is not managed by TTL or manual purging.
Cached content is treated as immutable at the edge and only updated when explicitly invalidated by runtime-driven logic.
It is updated in real time, at the URL level, based directly on business logic changes.
This prevents unnecessary traffic spikes and keeps system load stable even under dynamic content updates.
The system operates across both edge CDN and internal runtime caching layers, ensuring efficient load distribution and minimal origin pressure.
Even under transient failures, cached responses can be served to maintain system availability.
Infrastructure Capabilities
- Multi-database support (SQL + NoSQL)
- Distributed caching (L1 + L2)
- Built-in real-time messaging
These capabilities integrate directly with the runtime rather than existing as loosely coupled external components.
Service Ecosystem
Example services include:
- Portals (CMS)
- Users & Identity
- Files
- OTP & Security
- IP Location
All services operate as independent nodes within the runtime.
Summary
VIEApps NGX is not a microservices framework.
It is a communication runtime platform for distributed systems.
By moving control from infrastructure layers into a unified runtime, it enables scalable, resilient, and loosely coupled system architectures.