[Open Source] IACore: A battery-included C++20 foundation library (IPC, Async, HTTP, Logging) to escape dependency hell.

Hey friends,

Like many of you, I grew tired of "C++ Dependency Hell".. Every time I started a new project (specifically game engines and dev tools), I found myself wasting days setting up the same glue code: finding an HTTP library, setting up a job system, wrestling with platform-specific IPC, and configuring a logger.

I wanted a "bedrock" library—something I could drop into any project and immediately have the essentials working, without linking 50 different `.lib` files manually.

So I built **IACore**. It started as the internal core library for my work at **IASoft**, but I realized it solves a problem almost every C++ dev faces. I’ve cleaned it up, added tests, and I'm open-sourcing it under GPLv3 today.

**What's inside?** It wraps "best-in-class" dependencies into a unified, coherent C++20 API. It manages its own deps via CMake `FetchContent`, so you don't need to install anything manually.

* **⚡ IPC:** High-performance shared-memory ring buffers (wait-free SPSC).
* **🧵 Async:** A work-stealing job scheduler (High/Normal priority queues).
* **🌐 Networking:** A clean wrapper around `cpp-httplib` that handles Zlib/Gzip compression automatically.
* **📂 IO:** Memory-mapped file operations and optimized binary stream readers/writers.
* **🛠️ Modern:** Uses `std::span`, `tl::expected`, and C++20 concepts throughout.

**Where to get it:** [https://github.com/I-A-S/IACore](https://github.com/I-A-S/IACore)

Any and all feedback & questions are welcome! (Even the rude ones—I know how r/cpp can be sometimes 😆 ).

# Examples

**1. Async Tasks**

C++

#include <IACore/AsyncOps.hpp>

// Initialize worker threads (hardware_concurrency - 2)
IACore::AsyncOps::InitializeScheduler();

// Schedule a task
auto* mySchedule = new IACore::AsyncOps::Schedule();

IACore::AsyncOps::ScheduleTask([](auto workerID) {
printf("Running on worker %d\n", workerID);
}, 0, mySchedule);

// Wait for completion
IACore::AsyncOps::WaitForScheduleCompletion(mySchedule);

**2. HTTP Request**

C++

#include <IACore/HttpClient.hpp>

IACore::HttpClient client("https://api.example.com");
auto res = client.JsonGet<MyResponseStruct>("/data", {});

if (res) {
std::cout << "Data: " << res->value << "\n";
} else {
std::cerr << "Error: " << res.error() << "\n";
}

**3. IPC (Shared Memory Ring Buffer)**

*Manager:*

C++

#include <IACore/IPC.hpp>

// Spawns a child process and connects via Shared Memory
auto nodeID = manager.SpawnNode("MyChildNodeExe");
manager.WaitTillNodeIsOnline(*nodeID);

// Send data with zero-copy overhead
String msg = "Hello Node";
manager.SendPacket(*nodeID, 100, {(PCUINT8)msg.data(), msg.size()});

*Node:*

C++

#include <IACore/IPC.hpp>

class Node : public IACore::IPC_Node {
public:
void OnSignal(uint8_t signal) override {
// Handle signals
}

void OnPacket(uint16_t packetID, std::span<const uint8_t> payload) override {
// Handle packets
}
};

int main(int argc, char* argv[]) {
// The connection string is passed as the first argument by the Manager
if (argc < 2) return -1;

Node node;
// Connect back to the manager via Shared Memory
if (!node.Connect(argv[1])) return -1;

while(true) {
node.Update();
}
return 0;
}

https://redd.it/1pni3y8
@r_cpp