Ivyware Pty Ltd Message routing, message storage & technical analysis Founded 1999 Melbourne, AU
Ivyware

TargetCore — the routing kernel

One address.
Any transport.
Every message routed.

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.

One hub, four transports, mapped handlers TRANSPORTS P2PeerConWsa P2PeerConPipe P2PeerCon232 P2PeerConDmx P2PEERHUB Root.MyHub QUEUE PUMPS THREAD POOL P2PeerMsg_MAP 42 → onChat 17 → onStatus CON → onAccept
Connection classes converge · one queue · shared pumps · mapped handlers
2002Kernel in service since
2000Store in service since
2Operating systems, one source tree
9Languages with a green harness
4Transports in the box
0Connections accepted unauthenticated, by default

Two libraries, one application

Msgcore since 2000 · TargetCore since 2002

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

Foundation — developer library

Msgcore

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
  • 282 flat C entry points, each with a UTF-8 twin

Application — built on both

Chartboard

Technical analysis workspace · Windows

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

One kernel, every runtime

Windows · Linux · nine languages

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.

Callers in many languages, one hub on each operating system, one wire between them CALLERS C++ · TargetFacade PowerShell · TargetCom C# · .NET interop Java · Panama FFI VBScript · VBA · Excel PHP · JS in the browser WINDOWS · IOCP · CNG P2PEERHUB Root.Win SAME SOURCE TREE ECDH · AES-GCM TCP · SIGNED LOGIN LINUX · IO_URING · OPENSSL P2PEERHUB Root.Win.Linux SAME IMAGE, BYTE FOR BYTE HANDLER onChat AUTH REQUIRED BY DEFAULT · NO ALGORITHM NEGOTIATION
Nine callers · one address space · two operating systems · one wire

Ten lines, any language

TargetFacade · TargetCom

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 object
p2pf::Hub server = net.createHub(L"Demo");
server.onTopic(L"chat", [](const p2pf::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 transport

p2pf::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 lines
Set 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

Same hub, different wire

Transports

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.

Watch a message get routed

Eight calls, start to finish

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.