You signed in with another tab or window. Reload to refresh your session.You signed out in another tab or window. Reload to refresh your session.You switched accounts on another tab or window. Reload to refresh your session.Dismiss alert
Nodepp is the end of excuses. For too long, developers have settled for **fragmented glue-ware** or managed runtimes that treat hardware resources like garbage. Nodepp is a vertically-integrated C++ framework that proves you don't need a massive Virtual Machine or a bloated Garbage Collector to write high-level async code.
8
9
9
-
**Nodepp**is a vertically integrated C++ runtime engineered to eliminate the Hardware Tax in cloud and edge computing. It bridges the gap between high-level developer velocity and low-level mechanical sympathy.
10
+
While others are busy **masturbating the CPU**— burning millions of cycles on garbage collection, context switching, and runtime management — Nodepp focuses on Pure Execution. It provides a unified world architecture where every module shares the same high-efficiency DNA, scaling from an 8-bit Arduino to an Intel XEON cloud server.
10
11
11
12
```
12
13
NODEPP UNIFIED ARCHITECTURE: Co-designed components MODEL
@@ -32,15 +33,23 @@ NODEPP UNIFIED ARCHITECTURE: Co-designed components MODEL
32
33
33
34
## 📃 Whitepaper
34
35
35
-
[Scaling the Talent Bridge for Green Computing: Achieving Silicon-Logic Parity through Deterministic RAII](https://nodeppofficial.github.io/nodepp-doc/whitepaper) Read the full technical breakdown, including architectural deep-dives into `ptr_t`, `kernel_t` and `coroutine_t`.
36
+
[Nodepp: Closing the Gap Between Bare-Metal Performance and Scripting Agility through Silicon-Logic Parity](https://nodeppofficial.github.io/nodepp-doc/whitepaper) Read the full technical breakdown, including architectural deep-dives into `ptr_t`, `kernel_t` and `coroutine_t`.
-**📌: 1. Deterministic RAII (`ptr_t`):** Eliminates the unpredictable latency spikes (Stop-the-World) of Garbage Collectors. By utilizing Small Stack Optimization (SSO) and reference counting, memory is reclaimed with microsecond precision.
41
+
42
+
-**📌: 2. Cooperative Multitasking (`coroutine_t`):** Stackless coroutines eliminate context-switching overhead. This allows for massive connection density on low-power hardware, from 8-bit industrial sensors to cloud-scale reactors.
43
+
44
+
-**📌: 3. Platform-Agnostic Reactor (`kernel_t`):** A unified abstraction over native kernel I/O `(Epoll, Kqueue, IOCP, and Npoll)`. It provides a consistent non-blocking interface across Linux, Windows, Mac, and Bare-Metal, ensuring that I/O multiplexing is always native to the silicon.
38
45
39
-
In the post-Moore's Law era, hardware is no longer infinitely cheap. Traditional managed runtimes (Node.js, Go, Java) prioritize abstractions that create a 11,000x Virtual Memory Gap. Nodepp reclaims this efficiency, enabling Resource-Dense Computing where a single node does the work of an entire cluster.
46
+
## 🖕 Technical Reality Check: Data vs. Hype
40
47
41
-
### 📈 Performance Benchmark: HTTP Throughput vs. Resource Tax
48
+
We didn't test this on a supercomputer. We tested it on an educational-grade Dual-Core Apollo Lake potato. If your framework can't perform here, it's not "scalable" — it's just hiding behind hardware.
42
49
43
-
> **Test:** 100k requests | 1k Concurrency | Environment: Localhost | Device: Educational-grade Dual-Core Apollo lake Chromebook [see benchmark](https://github.com/NodeppOfficial/nodepp/blob/main/benchmark/server_benchmark/readme.md)
50
+
**1 - Performance Benchmark: HTTP Throughput vs. Resource Tax**
> **Note:** Go's <1ms measurement reflects allocation latency only; reclamation is deferred to concurrent garbage collection cycles.
72
+
> **Note:** Go's <1ms measurement is a lie — it only reflects allocation latency. Reclamation is deferred to concurrent GC cycles, creating "ghost" resource pressure.
-**📌: 1. Deterministic RAII (`ptr_t`):** Eliminates the unpredictable latency spikes (Stop-the-World) of Garbage Collectors. By utilizing Small Stack Optimization (SSO) and reference counting, memory is reclaimed with microsecond precision.
98
+
The Nodepp Project did not originate in a laboratory; it was forged in the trenches of mission-critical Edge Computing and WASM development. While architecting ecosystems that bridge ESP32 hardware, web browsers, and cloud infrastructure, we identified a systemic crisis: the forced fragmentation of a single business logic across three incompatible execution environments.
90
99
91
-
-**📌: 2. Cooperative Multitasking (`coroutine_t`):** Stackless coroutines eliminate context-switching overhead. This allows for massive connection density on low-power hardware, from 8-bit industrial sensors to cloud-scale reactors.
-**The Infrastructure:** Managed Runtimes like Python, Go, or Node.js for server-side orchestration (High operational cost, unpredictable latency due to Garbage Collection).
103
+
104
+
Nodepp was built to collapse these silos. By providing a unified, asynchronous C++ runtime that mirrors the productivity of scripting languages, we enable Resource-Dense Computing.
105
+
106
+
```cpp
107
+
#include<nodepp/nodepp.h>
108
+
#include<nodepp/http.h>
109
+
110
+
usingnamespacenodepp;
111
+
112
+
voidonMain() {
113
+
114
+
fetch_t args;
115
+
args.method = "GET";
116
+
args.url = "http://ip-api.com/json/?fields";
117
+
args.headers = header_t({
118
+
{ "Host", url::host(args.url) }
119
+
});
120
+
121
+
http::fetch( args )
122
+
123
+
.then([]( http_t cli ){
124
+
auto data = stream::await( cli );
125
+
console::log("->", data.value());
126
+
})
127
+
128
+
.fail([]( except_t err ){
129
+
console::error( err );
130
+
});
131
+
132
+
}
133
+
```
134
+
135
+
We restore the direct relationship between code and hardware through Deterministic RAII and Stackless Coroutines, allowing you to deploy the same high-level logic from an 8-bit microcontroller to a 64-core cloud reactor without changing your mental model.
136
+
137
+
**Still Skeptical?**
138
+
139
+
Watch logic-parity in action. This isn't a "concept"—it's [ A Fully Functional Enigma Machine running in a Literal Potato board ](https://wokwi.com/projects/449104127751150593):
92
140
93
-
-**📌: 3. Platform-Agnostic Reactor (`kernel_t`):** A unified abstraction over native kernel I/O (Epoll, Kqueue, IOCP, and Npoll). It provides a consistent non-blocking interface across Linux, Windows, Mac, and Bare-Metal, ensuring that I/O multiplexing is always native to the silicon.
0 commit comments