Industrial software and embedded systems developer focused on reliable tools for production, firmware, diagnostics, and edge systems.

I build small, focused C/C#/C++ libraries and applications for real-world use: embedded storage, runtime safety, industrial communication, monitoring, data acquisition, and practical AI-assisted development workflows.

My usual design bias:

• predictable behavior
• small integration surface
• clear failure modes
• zero or minimal dependencies
• tests before claims
• tools that solve real problems, not demo problems

I am currently looking for collaborators who can help with testing, hardware validation, examples, documentation review, and real-world feedback on embedded C projects.

Main areas:

• embedded C testing
• MCU hardware validation
• storage and power-loss testing
• reliability and diagnostics
• industrial/edge use cases
• examples and integration feedback

If you are working with firmware, MCU platforms, RTOS/bare-metal systems, or industrial devices and want to test or review any of these projects, feel free to reach out.

loxdb is a compact embedded database written in C99 for firmware and small edge runtimes.

It combines three storage models behind one API surface:

• KV for configuration, cache entries, and TTL-backed state
• Time-series for sensor samples and rolling telemetry
• Relational fixed-schema tables for small indexed structured data

Core design:

• one allocation at lox_init()
• fixed RAM budgeting
• zero external dependencies
• RAM-only or storage-backed operation
• optional WAL-backed persistence and recovery
• embedded-first storage HAL

loxdb is not a tiny SQLite clone. SQLite is excellent, but targets a different operating point. loxdb is intentionally narrower: deterministic storage for constrained firmware, dataloggers, controllers, and small edge runtimes where predictable memory and a small integration surface matter more than SQL features.

License: MIT open-source core.
Commercial extension: loxdb_pro_docs contains public API-level documentation for the planned/commercial PRO module set.

loxdb_pro_docs documents the public integration-facing API for the commercial loxdb_pro layer.

The PRO layer is designed for embedded products that need more than storage:

• security and integrity
• runtime safety validation
• metrics, logging, monitoring, and alerting
• policy gates, quotas, retention, and scheduling
• backup and schema migration
• replication and transport framing
• OTA planning and rollback hooks
• CLI tooling
• optional SD card and NAND/FTL adapters

The public repository intentionally contains documentation only. The implementation and proprietary validation procedures are not published there.

loxguard is a lightweight C99 guard-runtime for embedded C.

It introduces Guard Blocks and Checked Guard Blocks: explicit execution boundaries around risky code such as parsers, protocol handlers, optional modules, and recovery-sensitive routines.

Instead of only failing with an assert or watchdog reset, loxguard turns failures into structured runtime evidence:

• lifecycle events
• policy decisions
• blackbox records
• reports
• CSV/KV import-export paths
• optional persistence and ecosystem adapters

Current scope includes checked span/arena primitives, Guard Block lifecycle tracking, failure reporting, policy decisions, local blackbox evidence, and host-tested integration paths.

loxguard does not claim full memory safety for arbitrary C code and is not a safety-certified framework. Its value is narrower: make unsafe execution states easier to detect, record, and react to in small embedded C systems.

loxc is an experimental trainable text codec written in C99.

It is designed for cases where the developer already knows the type of text data being transmitted or stored — for example MQTT payloads, telemetry messages, logs, JSON-like records, protocol text, or other repetitive domain-specific data.

Instead of trying to be a universal compressor, loxc lets you train a codec table from representative sample data, export that table, transfer it, and load it later in an application, tool, or embedded runtime.

Core ideas:

• frequency-based symbol selection
• matrix-based symbol layout
• nested submatrices for less frequent data
• binary encoded output
• trained lookup tables
• predictable table-driven decoding
• small C99 integration surface

loxc is not intended to compete with gzip, zstd, brotli, or lz4. Those are mature general-purpose compression systems.

The value of loxc is narrower: provide a small trainable codec option for developers who know their data and want a compact table-driven encoding path for specific text payloads.

It is not encryption and not a universal archive format.

loxbudget is a small, heap-free C99 library that decides whether an embedded operation should run — and at what level — based on configurable resource budgets, rate windows, and optional calibration.

It provides a deterministic pre-flight gate in front of risky firmware work: MQTT publish, OTA update, flash write, log burst, debug dump, parser invocation, queue allocation, or any operation that must be degraded, delayed, rejected, or allowed under pressure.

Core design:

• deterministic check / enter / leave decisions per operation profile
• no heap, no floats, no global mutable state (all state is caller-owned storage)
• optional audit ring buffer for recent decisions
• optional rate windows and lifetime limits
• optional calibration and diagnostic strings
• single-header amalgamated distribution option
• stable public API starting at v1.0.0 (semver)

Typical use cases:

• prevent MQTT storms from exhausting queue slots
• block OTA when voltage or flash budget is unsafe
• degrade logging under memory pressure
• reject non-critical work during survival mode
• enforce flash-write lifetime budgets

loxbudget is not a scheduler, allocator, watchdog, logger, profiler, or RTOS replacement. Its value is narrower: an admission-control layer that gives firmware a deterministic answer to "may this operation run right now, and how?".

License: MIT.

A collection of composable libraries sharing the same philosophy:

no heap, no dependencies, no code generation — just #include and go.

• microsh — debug shell with history and tab completion.
• microlog — multi-backend structured logging.
• microfsm — table-driven finite state machine engine.
• microres — retry with backoff, circuit breaker, and rate limiter.
• microconf — schema-driven config with CRC and flash storage.
• microcbor — minimal CBOR encoder/decoder.
• micoring — generic lock-free SPSC ring buffer.
• microtimer — software timer manager for one-shot and periodic timers.
• microbus — topic-based event/pub-sub bus.
• iotspool — persistent MQTT store-and-forward queue.

Libraries that bridge embedded diagnostics, monitoring, recovery, and firmware lifecycle.

• microhealth — runtime health monitor with metrics and threshold-based alerts.
• microwdt — per-task software watchdog with escalation states.
• microboot — boot and recovery manager with crash-loop detection.
• microassert — unified panic system with hook chain and severity levels.
• microota — OTA update flow with chunking, CRC, version checks, commit/rollback.
• microflash — unified flash abstraction for NOR/EEPROM/FRAM/RAM-like storage.

Small utilities for writing safer and more debuggable embedded C.

• panicdump — crash dump library for Cortex-M3/M4: capture on fault, survive reboot, decode offline.
• MCU-Malloc-Tracker — deterministic heap diagnostics for bare-metal MCUs.
• nvlog — power-loss safe append log for FRAM/EEPROM/NOR flash.
• defer — automatic resource cleanup for C via DEFER() macro.
• cguard — scope guards and result types for C.
• safemath — overflow-checked arithmetic and buffer sizing helpers.
• microcrypt — SHA-256, HMAC-SHA256, AES-128 ECB/CBC.
• microdh — minimal X25519 key exchange for embedded systems.
• microtest — single-header C test framework.

• num8 — O(1) membership engine for 8-digit numbers using a fixed bitset.
• IronFamily.FileEngine — binary IoT file engines: config, structured logs, and firmware update package formats.

Desktop tools and firmware for real-world industrial communication.

• IOBusMonitor — multi-protocol desktop tool for Modbus TCP/RTU and Siemens S7 PLCs.
• RTULogSuite — complete Modbus RTU logging toolchain: ESP32 firmware + Windows visualization.
• iotspool — persistent store-and-forward MQTT queue.
• uMesh — lightweight mesh networking stack for ESP32 over raw 802.11.
• num8-lup — low-bandwidth update propagation protocol for constrained links.

• MultiGpuHelper — C# library for scheduling compute workloads across multiple GPUs.
• CrudFramework — lightweight CRUD framework for .NET, EF Core, SQLite/SQL Server, and WPF-ready bindings.

• securebox-hw — secure hardware password manager concept on ESP32-S3 with external encrypted storage.
• Pragotron-Controller — minute-impulse controller for a Pragotron stepper clock.

I am interested in embedded reliability, deterministic storage, firmware diagnostics, industrial data systems, and practical AI-assisted engineering.

Most of my projects follow the same rule:

small code, clear contracts, real tests, and no claims without evidence.