Projects on Tucker Strausbaugh

tsim: Modular Multi-Domain Defense Simulation Platform

Sun, 06 Sep 2026 17:00:00 -0400

tsim is a high-performance, modular simulation suite built in C++20 to bridge the gap between military protocol interoperability, sensor kinematics, physical-layer RF signal environments, and orbital mechanics. Rather than relying on monolithic, opaque simulation frameworks, tsim is structured as a decoupled ecosystem of high-throughput libraries and companion services designed for composition.

Foundational Graphics & Compute Engine: tsim’s entire visualization and real-time GPU compute layer is built directly on WGFX: Modern WebGPU & C++20 Graphics Engine. WGFX manages the underlying Google Dawn device contexts, compute shader dispatches, reactive frame scheduling, and Dear ImGui / ImPlot harnesses across iqgen, waterfall, satviz, and antenna.

WGFX: Modern WebGPU & C++20 Graphics Engine

Sun, 06 Sep 2026 16:00:00 -0400

WGFX is a modern C++20 graphics and compute engine built on top of Google Dawn, the reference implementation of WebGPU. It bridges the gap between low-level GPU hardware control and high-level developer ergonomics for real-time scientific visualization, signal processing simulations, and interactive 3D engineering tooling.

Architectural Philosophy & Core Design

Traditional desktop graphics programming often forces an uncomfortable compromise: the heavyweight complexity and multi-thousand-line boilerplate of raw Vulkan or DirectX 12, versus the outdated driver quirks and state-machine baggage of legacy OpenGL.

Msg: High-Performance C++20 Pub/Sub Messaging

Sat, 01 Aug 2026 12:00:00 -0400

Distributed systems, high-performance computing clusters, and real-time simulations rarely rely on a single networking transport. One subsystem might require ultra-low-latency point-to-point UDP multicast, another relies on an enterprise message broker like NATS, while a third pushes updates through Redis.

Msg is a modern C++20 library designed to decouple application code from transport mechanics. It unifies transport protocols, in-flight compression, and message serialization behind a clean, URI-driven publish/subscribe interface.

URI-Based Configuration

Rather than writing transport-specific initialization boilerplate, msg configures endpoints via a concise URI schema:

GFX: Lightweight Raylib & ImGui Multimedia Framework

Sat, 11 Apr 2026 15:00:00 -0400

When exploring physics models, signal processing algorithms, or custom graphics techniques, full-scale game engines (Unreal, Unity) introduce unnecessary friction, while raw OpenGL or Vulkan requires excessive boilerplate just to draw a cube with a UI overlay.

GFX was created as a lightweight, clean C++ application harness combining Raylib, Dear ImGui, and miniaudio. It provides a rapid sandbox for interactive 3D simulations, real-time plotting, and audio generation.

Framework Design

The core of the library is gfx::App, which wraps window initialization, input polling, multi-sampling (4X MSAA), camera management, audio engine lifecycle, and ImGui integration into an intuitive subclassing interface:

IEX Market Data to Parquet Pipeline

Sat, 27 Dec 2025 10:00:00 -0400

The Investors Exchange (IEX) publishes daily historical market data as raw network packet captures (.pcap / .pcapng). These files capture every UDP packet transmitted across the exchange’s market data distribution network.

While PCAP files are great for network debugging, querying hundreds of gigabytes of raw binary packet captures for quantitative analysis or order book reconstruction is painfully slow.

iex_to_parquet is a high-performance C++ parser and data pipeline that ingests raw PCAP network dumps and streams them directly into compressed, columnar Apache Parquet datasets.

ADS-B Flight Tracking to Parquet Converter

Fri, 05 Dec 2025 11:00:00 -0400

ADS-B (Automatic Dependent Surveillance–Broadcast) is the backbone of modern global aviation tracking. Aircraft continuously broadcast their satellite-derived position, altitude, velocity, and transponder identification over 1090 MHz and 978 MHz RF links.

ADS-B Exchange provides historical trace dumps containing billions of aircraft observation records. However, querying raw monthly archives formatted as deeply nested, multi-gigabyte JSON files creates a massive data processing bottleneck.

adsb_to_parquet is a high-throughput C++ data processing tool designed to parse raw ADS-B trace dumps and stream them directly into columnar Apache Parquet format.

ENTDLR: Entity Definition Language Redux

Sat, 04 Oct 2025 13:00:00 -0400

When engineering complex, heterogeneous systems—such as real-time C++ simulation kernels communicating with C# operator displays, Rust network bridges, and Python telemetry analysis pipelines—maintaining synchronized data models and serialization code by hand is tedious and error-prone. A single mismatched byte offset, unaligned integer, or forgotten struct member can cause silent memory corruption or subtle network protocol failures across platforms.

ENTDLR (Entity Definition Language Redux) is an extensible Interface Definition Language (IDL) compiler and multi-language code generation engine built in modern C++17. It takes schema definitions written in an extended Google FlatBuffers grammar, parses them through an ANTLR4 frontend into a strongly typed in-memory Abstract Syntax Tree (Context), and renders production-ready code through the Inja template engine—augmented by an embedded Wren scripting runtime for complex generation logic.

Home Sensor: Distributed Environmental Telemetry Network

Wed, 16 Apr 2025 09:00:00 -0400

Monitoring indoor microclimates, air quality dynamics, and ambient illumination across multiple floors presents surprising engineering challenges. Consumer-grade smart home sensors are frequently closed-source, cloud-dependent, sample at coarse intervals, and trap heat from internal radios—biasing temperature and humidity readings. Furthermore, managing time-series telemetry across battery-backed or wall-powered nodes requires resilient local failover when Wi-Fi drops, low-drift sampling intervals, and sub-millisecond database ingestion.

Home Sensor is an end-to-end, multi-node environmental monitoring platform engineered from the ground up. It spans custom ESP32 sensor pods with polymorphic C++ firmware, parametric 3D-printed convective enclosures, an ingestion and web daemon written in Go (Fiber v2), a column-oriented QuestDB time-series database, and a hyper-responsive frontend built with Templ, HTMX, and Apache ECharts.

Crappy Traffic Sim (C++)

Fri, 21 Apr 2017 09:51:47 -0400

I wrote this late one night where I went down the rabbit hole of simulating traffic. It has each vehicle as its own thread, which is completely unnecessary for what it currently does. Right now the vehicles are given an average speed and its speed is modified with some noise, and does some basic collision detection.

The idea is to eventually develop and train a simple neural network to drive each vehicle. In order to do this I started trying to write my own very simple neural network library.

Single Neuron Perceptron (C++)

Fri, 21 Apr 2017 08:54:59 -0400

This is a basic implementation of a single neuron perceptron that can learn to act as AND, OR, and NAND gates in C++.

neuron.h

#ifndef __NEURON_H__
#define __NEURON_H__

#include <vector>
#include <tuple>

using namespace std;

class Neuron
{
public:
	Neuron(int numberOfInputs);

	~Neuron() {};

	double forward(vector<bool> inputs);

	bool forwardBinary(vector<bool> inputs);

	bool forwardBinaryCheck(vector<bool> inputs, bool answer);

	bool train(vector<bool> inputs, bool answers);

private:
	vector<double> weights; // input weights
	
	vector<Neuron> inputs; // for future backpropagation
	
	vector<Neuron> outputs; // for futude backpropagation

	double threshold; // trigger threshold

	double learningRate; //  how aggressive to tune the above values
};

#endif // __NEURON_H__

neuron.cpp

#include <iostream>
#include <math.h>

#include "neuron.h"

using namespace std;

Neuron::Neuron(int numberOfInputs)
{
	for (int i = 0; i < numberOfInputs; i++)
		weights.push_back(1.0 / numberOfInputs);

	threshold = 0.9;
	learningRate = 0.01;
}

double Neuron::forward(vector<bool> inputs)
{
	if (inputs.size() == weights.size())
	{
		double sum = 0.0;
		for (int i = 0; i < inputs.size(); i++)
			sum += inputs[i] * weights[i];

		return tanh(sum);
	}
	
	return -1;
}

bool Neuron::forwardBinary(vector<bool> inputs)
{
	if (inputs.size() == weights.size())
	{
		if (forward(inputs) > threshold)
			return true;
	}

	return false;
}

bool Neuron::forwardBinaryCheck(vector<bool> inputs, bool answer)
{
	if (inputs.size() == weights.size())
	{
		bool result = forwardBinary(inputs);

		if (result == answer)
			return true;
	}
	
	return false;
}

bool Neuron::train(vector<bool> inputs, bool answer)
{
	if (inputs.size() == weights.size())
	{
		bool result = forwardBinary(inputs);

		for (int i = 0; i < inputs.size(); i++)
			weights[i] += learningRate * ((double)answer - (double)result) * (double)inputs[i];

		threshold -= learningRate * ((double)answer - (double)result);

		/*for (int i = 0; i < weights.size(); i++)
			cout << "Weight " << i << ": " << weights[i] << "\n";
		cout << "Threshold: " << threshold << "\n";*/

		if (result == answer)
			return true;
	}

	return false;
}

main.cpp

#include "neuron.h"
#include "json.hpp"

#include <iostream>
#include <fstream>
#include <chrono>
#include <random>

using namespace std;
using json = nlohmann::json;

int main(int argc, char** argv)
{
	ifstream file("Answers.json");
	json answers;
	file >> answers;

	unsigned int seed = (unsigned int)chrono::system_clock::now().time_since_epoch().count();
	default_random_engine engine(seed);
	uniform_int_distribution<unsigned int> rand(0, 1);

	int numInputs = 3;
	unsigned int reps = 1000;

	Neuron neuron(numInputs);

	vector<bool> inputs;
	inputs.reserve(numInputs);
	vector<bool> results;
	inputs.reserve(reps);

	for (unsigned int i = 0; i < reps; i++)
	{
		for (int i = 0; i < numInputs; i++)
			inputs.push_back(rand(engine) != 0);

		bool answer = inputs[0];
		if (numInputs > 0)
		{
			for (int i = 1; i < numInputs; i++)
				//answer = answer || inputs[i]; // learn to be an OR gate
				answer = answer && inputs[i]; // learn to be an AND gate

			answer = !answer; // learn to be a NAND gate
		}

		results.push_back(neuron.train(inputs, answer));
		inputs.clear();
	}

	for (auto& result : results)
		cout << "result:  " << result << "\n";

	cout << "---------------------------------" << endl;
	// OR gate
	//cout << "correct: " << neuron.forwardBinaryCheck({ 0, 0, 0 }, false) << endl;
	//cout << "correct: " << neuron.forwardBinaryCheck({ 0, 0, 1 }, true) << endl;
	//cout << "correct: " << neuron.forwardBinaryCheck({ 0, 1, 0 }, true) << endl;
	//cout << "correct: " << neuron.forwardBinaryCheck({ 0, 1, 1 }, true) << endl;
	//cout << "correct: " << neuron.forwardBinaryCheck({ 1, 0, 0 }, true) << endl;
	//cout << "correct: " << neuron.forwardBinaryCheck({ 1, 0, 1 }, true) << endl;
	//cout << "correct: " << neuron.forwardBinaryCheck({ 1, 1, 0 }, true) << endl;
	//cout << "correct: " << neuron.forwardBinaryCheck({ 1, 1, 1 }, true) << endl;

	// AND gate
	//cout << "correct: " << neuron.forwardBinaryCheck({ 0, 0, 0 }, false) << endl;
	//cout << "correct: " << neuron.forwardBinaryCheck({ 0, 0, 1 }, false) << endl;
	//cout << "correct: " << neuron.forwardBinaryCheck({ 0, 1, 0 }, false) << endl;
	//cout << "correct: " << neuron.forwardBinaryCheck({ 0, 1, 1 }, false) << endl;
	//cout << "correct: " << neuron.forwardBinaryCheck({ 1, 0, 0 }, false) << endl;
	//cout << "correct: " << neuron.forwardBinaryCheck({ 1, 0, 1 }, false) << endl;
	//cout << "correct: " << neuron.forwardBinaryCheck({ 1, 1, 0 }, false) << endl;
	//cout << "correct: " << neuron.forwardBinaryCheck({ 1, 1, 1 }, true) << endl;

	// NAND gate
	cout << "check: " << neuron.forwardBinaryCheck({ 0, 0, 0 }, true) << endl;
	cout << "check: " << neuron.forwardBinaryCheck({ 0, 0, 1 }, true) << endl;
	cout << "check: " << neuron.forwardBinaryCheck({ 0, 1, 0 }, true) << endl;
	cout << "check: " << neuron.forwardBinaryCheck({ 0, 1, 1 }, true) << endl;
	cout << "check: " << neuron.forwardBinaryCheck({ 1, 0, 0 }, true) << endl;
	cout << "check: " << neuron.forwardBinaryCheck({ 1, 0, 1 }, true) << endl;
	cout << "check: " << neuron.forwardBinaryCheck({ 1, 1, 0 }, true) << endl;
	cout << "check: " << neuron.forwardBinaryCheck({ 1, 1, 1 }, false) << endl;

	return 0;
}

Async Monte Carlo Pi (C++)

Sat, 15 Apr 2017 17:37:11 -0400

This program uses C++11’s futures to estimate pi.

// Compile with the flags "-O3 -std=c++11"
// might need -pthread

#include <iostream>
#include <future>
#include <random>
#include <chrono>

using namespace std;

bool monteCarloPi(double x, double y)
{
    if (x*x + y*y < 1.0)
        return true;
    
    else
        return false;
}

long int piThread(long int reps)
{
    long int count = 0;
    
    unsigned int seed = (unsigned int)chrono::system_clock::now().time_since_epoch().count();
    default_random_engine engine(seed);
    uniform_real_distribution<double> rand(0, 1);
    
    for (long int i = 0; i < reps; i++)
    {
        if (monteCarloPi(rand(engine), rand(engine)))
            count++;
    }
    
    return count;
}

int main (int argc, char** argv)
{
    auto cores = thread::hardware_concurrency();
    cout << "cores: " << cores << endl;
    
    long int samples = 0;
    
    if (argc > 1)
        samples = atoll(argv[1]);
    
    cout << "samples: " << samples << endl;
    
    future<long int>* results = new future<long int>[cores];
    
    auto start = chrono::steady_clock::now();
    
    for (unsigned i = 0; i < cores; i++)
        results[i] = async(launch::async, piThread, samples/cores);
    
    long int total = 0;
    for (unsigned i = 0; i < cores; i++)
        total += results[i].get();
    
    double pi = ((double)total / double(samples)) * 4.0;
    
    auto duration = chrono::duration<double, milli>(chrono::steady_clock::now() - start);
    
    cout << "pi: " << pi << endl;
    cout << "runtime: " << duration.count() / 1000 << "s" << endl;
}

Monte Carlo Estimation of Pi (Rust)

Sat, 15 Apr 2017 17:37:05 -0400

This program uses futures to calculate pi using a monte carlo method. It randomly generates points and checks if they are inside of a unit circle. The proportion of the points inside and the total number of points are then used to estimate Pi.

extern crate rand;
extern crate time;
extern crate num_cpus;
extern crate futures;
extern crate futures_cpupool;

use std::env;
use rand::Rng;
use time::PreciseTime;
use futures::Future;
use futures_cpupool::CpuPool;

fn main() {
    let start = PreciseTime::now();

    let args: Vec<String> = env::args().collect();
    let reps: u64 = args[1].parse().unwrap();
    let cpus = num_cpus::get();
    let pool = CpuPool::new_num_cpus();

    let mut futures = Vec::new();
    for _ in 0..cpus {
        let input_reps = reps / cpus as u64;
        let future = pool.spawn_fn(move || {
            let count = monte_carlo_pi(input_reps);
            let res: Result<u64, ()> = Ok(count);
            return res;
        });

        futures.push(future);
    }

    let mut total_count: u64 = 0;
    for future in futures {
        total_count = total_count + future.wait().unwrap();
    }

    let pi = total_count as f64 / reps as f64 * 4.0;

    let end = PreciseTime::now();

    println!("pi: {0}", pi);
    println!("runtime: {0}", start.to(end));

    std::process::exit(0);
}

fn monte_carlo_pi(reps: u64) -> u64 {
    let mut count = 0;
    let mut rng = rand::thread_rng();

    for _ in 0..reps {
        if in_unit_circle(rng.gen::<f64>(), rng.gen::<f64>()) {
            count += 1;
        }
    }

    return count;
}

fn in_unit_circle(x: f64, y: f64) -> bool {
    if x*x + y*y < 1.0 {
        return true;
    } else {
        return false;
    }
}

Monte Carlo Estimation of Pi (GoLang)

Sat, 21 May 2016 09:41:33 -0400

This program uses goroutines to calculate a Monte Carlo estimation of Pi. It randomly generates points and them checks if its inside the circle. The proportion of the points inside and the total points is then used to estimate Pi.

On an Intel 3770k, it accurately estimates Pi to 4 decimal digits using 1 trillion random points in just over 5 seconds.

package main

import (
    "fmt"
    "math"
    "math/rand"
    "os"
    "runtime"
    "strconv"
    "sync"
    "time"
)

func monte_carlo_pi(radius float64, reps int, result *int, wait *sync.WaitGroup) {
    var x, y float64
    count := 0
    seed := rand.NewSource(time.Now().UnixNano())
    random := rand.New(seed)

    for i := 0; i < reps; i++ {
        x = random.Float64() * radius
        y = random.Float64() * radius

        if num := math.Sqrt(x*x + y*y); num < radius {
            count++
        }
    }

    *result = count
    wait.Done()
}

func main() {
    cores := runtime.NumCPU()
    runtime.GOMAXPROCS(cores)

    var wait sync.WaitGroup

    counts := make([]int, cores)

    samples, _ := strconv.Atoi(os.Args[1])

    start := time.Now()
    wait.Add(cores)

    for i := 0; i < cores; i++ {
        go monte_carlo_pi(100.0, samples/cores, &counts[i], &wait)
    }

    wait.Wait()

    total := 0
    for i := 0; i < cores; i++ {
        total += counts[i]
    }

    pi := (float64(total) / float64(samples)) * 4

    fmt.Println("Time: ", time.Since(start))
    fmt.Println("pi: ", pi)
    fmt.Println("")
}

Mutithreaded Sumation (GoLang)

Sat, 21 May 2016 08:41:34 -0400

This was my first attempt to write something that uses the simplicity of threading in Go using goroutines. The number of threads is determined in the program and the run time is calculated.

The performance of Go is really shown off when I compared the times to a similar single threaded program written in Python. For the sum of 1 through 1 billion, Python’s time was measured in minutes, and Go took less then a 10th of a second.

HTML Link Grabber (GoLang)

Sat, 21 May 2016 08:41:33 -0400

This program takes in a web address as a command line argument. Then goes and gets that page and then prints out all of the links to other pages. While not all that useful, it was a good first step into web programming.

Credit for this goes to Jack Canty’s website because I’ve never written anything like this. His can be found here.

package main
import (
    "fmt"
    "flag"
    "net/http"
    "os"
    "io"
    "golang.org/x/net/html"
)

func main() {
    flag.Parse()
    arg := flag.Args()
    fmt.Println(arg)

    if len(arg) == 0 {
        fmt.Printf("Enter a page\nex. \"http://google.com\"")
        os.Exit(1)
    }

    data, error := http.Get(arg[0])   
    if error != nil {
        return
    }
    defer data.Body.Close()
    links := collectLinks(data.Body)

    for _, link := range(links) {
        fmt.Printf("\t")
        fmt.Println(link)
    }
}

func collectLinks(httpBody io.Reader) []string {
    links := make([]string, 0)
    page := html.NewTokenizer(httpBody)
    for {
        tokenType := page.Next()
        if tokenType == html.ErrorToken {
            return links
        }
        token := page.Token()
        if tokenType == html.StartTagToken && token.DataAtom.String() == "a" {
            for _, attr := range token.Attr {
                if attr.Key == "href" {
                    links = append(links, attr.Val)
                }
            }
        }
    }
}