A hub owns an address on a virtual network, keeps a priority queue, and runs pump threads that hand each message to a handler. Where the peer actually lives — same process, next machine, other side of a serial cable — is a choice of connection class, not a rewrite. TargetCore has been doing this in production since 2002.
It builds on Windows and Linux from one tree, authenticates and encrypts every connection by default, and is one line away from C++, C, Java, C#, PowerShell, VBScript, PHP and the browser. The message it routes is a Msgcore store: one heap, every field addressed by offset, nothing to serialise on the way out.
Msgcore defines what a message is. TargetCore gives it an address and moves it. Chartboard is what the two of them look like when they ship as a product. The dependency runs one way only — Msgcore knows nothing about networks, and the kernel defines no payload format of its own.
Flagship — developer library
TargetCore
Message routing · C++ · Java · Windows & Linux
The routing kernel. Hubs take hierarchical addresses, messages carry a priority and a code, and handlers are bound by map macros — or by lambdas, through the macro-free facade. Connection state and message dispatch are pumped through shared threads, so a connection costs an object, not a thread.
Hierarchical virtual addressing, independent of IP
Priority message queue with pooled pump threads
TCP, named pipes, RS-232 and in-process direct memory exchange
ECDH P-256 key exchange and AES-256-GCM, on by default
One header for C++; one ProgID for scripts and .NET
Structured message store · C++ · C · Java · COM · Windows & Linux
The store underneath. One manager owns one heap, and every field, value, child and attribute in it is addressed by offset rather than by pointer — so the whole store is a contiguous image that saves and loads verbatim, with no serialisation pass in between, and is byte-identical across operating systems.
Hierarchical, self-describing, field- and path-addressed
Offsets, not pointers — growth never invalidates the image
Save is a byte copy; load is header-validated and atomic
List, vector, stack and cursor containers inside the heap
A workspace-centred charting, portfolio, modelling and scanning application. Every internal component talks over the same message kernel, which is how the embedded Python interpreter, the paged datastore and the chart engine stay decoupled.
OHLC and Point & Figure charts, fully serialised
Thirty-odd oscillators, twenty-odd overlays, harmonics and regressions
Paged in-memory datastore — no SQL server to deploy
Python 3.11 advisor, modelling and scanner scripts
Portfolio positions, trade modelling and market replay
A script on Windows posts a message. It crosses an encrypted wire to a hub on Linux and lands in a handler there, and nothing in between knows or cares what language either end was written in. The address is the whole handle.
Nine callers · one address space · two operating systems · one wire
The kernel's native surface is MFC classes and map macros. The facade wraps it in one header and one init object; the COM layer puts the same hubs one CreateObject away. Two hubs, one wire, one message, in whichever of these you already write.
#include "TargetFacadeFn.hpp"p2pf::Network net; // one init objectp2pf::Hub server = net.createHub(L"Demo");
server.onTopic(L"chat", [](constp2pf::Message& m) { // no message map
wprintf(L"%s: %s\n", m.source, m.text());
});
server.listen(L"Demo.Client", L"tcp://:7788"); // the scheme picks the transportp2pf::Hub client = net.createHub(L"Demo.Client");
client.connect(L"Demo", L"tcp://127.0.0.1:7788");
client.sendText(L"Demo", L"chat", L"hello");
$net = New-Object -ComObject TargetCom.P2PNetwork# no compiler, no header$server = $net.CreateHub("Demo")
$server.Listen("Demo.Client", "tcp://:7788")
$client = $net.CreateHub("Demo.Client")
$client.Connect("Demo", "tcp://127.0.0.1:7788")
while (-not $client.IsPeerUp("Demo")) { Start-Sleep -Milliseconds 50 }
$client.SendText("Demo", "chat", "hello from PowerShell")
$server.Broadcast("news", "to everyone") # True: a peer took a copy
Set net = CreateObject("TargetCom.P2PNetwork") ' VBA and Excel: the same linesSet server = net.CreateHub("Demo")
server.Listen "Demo.Client", "tcp://:7788"Set client = net.CreateHub("Demo.Client")
client.Connect "Demo", "tcp://127.0.0.1:7788"Do While Not client.IsPeerUp("Demo") : WScript.Sleep 50 : Loop
client.SendText "Demo", "chat", "hello from VBScript"If server.Broadcast("news", "to everyone") Then WScript.Echo "delivered"
dynamic net = Activator.CreateInstance(Type.GetTypeFromProgID("TargetCom.P2PNetwork"));
dynamic server = net.CreateHub("Demo");
server.Listen("Demo.Client", "tcp://:7788");
dynamic client = net.CreateHub("Demo.Client");
client.Connect("Demo", "tcp://127.0.0.1:7788");
while (!client.IsPeerUp("Demo")) Thread.Sleep(50);
client.SendText("Demo", "chat", "hello from C#");
// early-bound: sink _IP2PHubEvents for OnMessage, OnPeerUp, OnPeerDown, OnError
Every connection gets ephemeral ECDH P-256, HKDF-SHA256 and AES-256-GCM. Every login carries an ECDSA P-256 signature bound to that exact exchange. A hub that requires authentication and holds no identity does not start up quietly insecure; it refuses to arm and names the missing file.
A connection is a typed transport bolted to a hub. Swap the class and the routing is unchanged — the address, the queue and the map stay exactly as they are. Through the facade the swap is one string: tcp://, pipe://, serial:// or dmx://.
P2PeerConWsaTCP sockets over the network. IOCP on Windows, io_uring on Linux.
P2PeerConPipeNamed pipes between local processes, hardened against remote and squatting clients. AF_UNIX on Linux.
P2PeerCon232RS-232 serial to attached hardware. termios on Linux.
P2PeerConDmxDirect memory exchange inside one process. Still a pumped message, still encrypted.
Who builds on it
Shapes of problem
Industrial & embedded
Serial at one end, TCP at the other
A device on RS-232 and a service on the LAN sit in one address space. The bridge is a hub with two connection classes, and the handler that reads the instrument does not know a network is involved.
Enterprise integration
Foreign APIs, wrapped in a hub
SQL Server, MAPI mail, MFC user interfaces and audio each become a hub with a second pump for whatever the API insists on serialising. The rest of the network sends messages and gets messages back.
Scripting & automation
Operators without a compiler
A PowerShell operator, an Excel macro or a VBScript logon script creates a hub, sends, and traps an error with a sentence in it. The same hubs the C++ services run.
Web & edge
A front door made of hubs
P2PeerWeb answers HTTP and HTTPS by turning each request into a message routed down a tree of site and session hubs, with certificates from Let's Encrypt built in. It serves this company's own site.
Bridges to the rest of the estate
Integrations
Each of these is a hub with a second, dedicated pump: the primary context keeps pre-empting and routing messages while the specialist pump serialises whatever the foreign API insists on serialising.
Name the hub, allocate it, map a code, start the pumps, listen, accept a peer, exchange keys, and post a message. The walkthrough steps through all eight with the caller code and the event log beside it. Then see the store's heap grow without a single pointer moving, and a connection arm from socket to signed login.