<rss version="2.0" xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:atom="http://www.w3.org/2005/Atom"><channel><title>Hacker News: obinexus</title><link>https://news.ycombinator.com/user?id=obinexus</link><description>Hacker News RSS</description><docs>https://hnrss.org/</docs><generator>hnrss v2.1.1</generator><lastBuildDate>Mon, 07 Sep 2026 11:06:07 +0000</lastBuildDate><atom:link href="https://hnrss.org/user?id=obinexus" rel="self" type="application/rss+xml"></atom:link><item><title><![CDATA[New comment by obinexus in "Mmuko Boot Sequence – a tiny freestanding C kernel that boots in QEMU"]]></title><description><![CDATA[
<p>MMUKO Boot is an experimental boot scaffold for building MMUKO as a freestanding operating-system environment rather than a normal hosted C application.<p>It currently supports two boot paths: a direct 512-byte BIOS boot sector and GRUB Multiboot. The direct path loads the kernel from disk, switches the CPU into 32-bit protected mode, and enters a freestanding C kernel_main(). The GRUB path performs the same MMUKO boot sequence through Multiboot.<p>The project runs under QEMU and includes assembly entry points, linker scripts, a freestanding C kernel, serial/VGA output, and Windows/Unix build paths.<p>I’m exploring how far the architecture can evolve toward a small, modular kernel with a stable ABI and independently replaceable components. Feedback on the boot architecture, kernel boundary, and next steps would be very welcome.</p>
]]></description><pubDate>Thu, 03 Sep 2026 18:05:12 +0000</pubDate><link>https://news.ycombinator.com/item?id=49554103</link><dc:creator>obinexus</dc:creator><comments>https://news.ycombinator.com/item?id=49554103</comments><guid isPermaLink="false">https://news.ycombinator.com/item?id=49554103</guid></item><item><title><![CDATA[Mmuko Boot Sequence – a tiny freestanding C kernel that boots in QEMU]]></title><description><![CDATA[
<p>Article URL: <a href="https://github.com/obinexus/mmuko-boot">https://github.com/obinexus/mmuko-boot</a></p>
<p>Comments URL: <a href="https://news.ycombinator.com/item?id=49554102">https://news.ycombinator.com/item?id=49554102</a></p>
<p>Points: 9</p>
<p># Comments: 2</p>
]]></description><pubDate>Thu, 03 Sep 2026 18:05:12 +0000</pubDate><link>https://github.com/obinexus/mmuko-boot</link><dc:creator>obinexus</dc:creator><comments>https://news.ycombinator.com/item?id=49554102</comments><guid isPermaLink="false">https://news.ycombinator.com/item?id=49554102</guid></item><item><title><![CDATA[Show HN: LibPolyCall – a C runtime broker for cross-language function calls]]></title><description><![CDATA[
<p>LibPolyCall is an open-source C runtime for connecting programs across language boundaries without requiring each language pair to implement its own integration layer.<p>The architecture is program-first rather than binding-first, with a stable C ABI, FFI bindings, Polycallfile/Polycallrc configuration, runtime state management, and telemetry.<p>I’ve recently completed the Windows build path producing both libpolycall.dll and libpolycall.a, and I’m working toward using the same runtime across Python, Node.js, Java, Go, and other language environments.<p>I’d particularly appreciate feedback on the ABI design, runtime architecture, configuration model, and approach to cross-language dynamic loading.</p>
<hr>
<p>Comments URL: <a href="https://news.ycombinator.com/item?id=49553255">https://news.ycombinator.com/item?id=49553255</a></p>
<p>Points: 4</p>
<p># Comments: 0</p>
]]></description><pubDate>Thu, 03 Sep 2026 17:05:39 +0000</pubDate><link>https://github.com/obinexus/libpolycall-v1</link><dc:creator>obinexus</dc:creator><comments>https://news.ycombinator.com/item?id=49553255</comments><guid isPermaLink="false">https://news.ycombinator.com/item?id=49553255</guid></item><item><title><![CDATA[Circuit Loop Theory: a mathematical formalism for electromagnetic boundaries]]></title><description><![CDATA[
<p>Article URL: <a href="https://github.com/obinexus/circuit_loop_theory/blob/main/CLP_CLA_Mathematical_Formalism.md">https://github.com/obinexus/circuit_loop_theory/blob/main/CLP_CLA_Mathematical_Formalism.md</a></p>
<p>Comments URL: <a href="https://news.ycombinator.com/item?id=49525163">https://news.ycombinator.com/item?id=49525163</a></p>
<p>Points: 1</p>
<p># Comments: 0</p>
]]></description><pubDate>Tue, 01 Sep 2026 17:36:12 +0000</pubDate><link>https://github.com/obinexus/circuit_loop_theory/blob/main/CLP_CLA_Mathematical_Formalism.md</link><dc:creator>obinexus</dc:creator><comments>https://news.ycombinator.com/item?id=49525163</comments><guid isPermaLink="false">https://news.ycombinator.com/item?id=49525163</guid></item><item><title><![CDATA[Show HN: Rift (Flexible Translator) – Build Languages in Days, Not Years]]></title><description><![CDATA[
<p>Text:
Hi HN! I'm Nnamdi from OBINexus Computing. RIFT stands for "RIFT Is a Flexible Translator" – a compiler toolchain that's a direct competitor to YACC, but designed for rapid language development.
The Problem: YACC takes 6 months to learn and 6 months to build a prototype. That's a year just to start. It's not compile-time safe, and it's painful to work with.
RIFT's Solution:<p>Configuration-based language building (not code generation)
Compile-time safety through token triplets (type, memory, value)
Stage-bound execution pipeline (0-6 stages)
R-syntax for inline regex without escape hell
Build a working language prototype in days<p>Key Innovation: The token triplet system ensures compile-time safety:
ctypedef struct {
    token_type;    // identifier, keyword, constant
    token_memory;  // static, dynamic, fluid
    token_value;   // immediate, deferred, computed
} rift_token_t;
Real Usage: I'm using RIFT to build GosiLang – a polyglot language that talks to any programming language (interpreted or compiled). What took a year with YACC now takes weeks.
Technical Details:<p>Written in C (migrating to Rust for R-syntax support)
Stage-bound configuration: .riftrc.N files
Error zones: 0-3 (OK), 3-6 (Warning), 6-9 (Critical), 9-12 (Panic)
Detach mode for full language independence<p>Currently building the community around RIFT philosophy. Looking for "RIFTers" who want to build languages without the traditional pain.
GitHub: <a href="https://github.com/obinexus/rift" rel="nofollow">https://github.com/obinexus/rift</a>
Video walkthrough: <a href="https://www.youtube.com/watch?v=rLkzHF7LXUA" rel="nofollow">https://www.youtube.com/watch?v=rLkzHF7LXUA</a> (28min technical deep dive)
Ecosystem: <a href="https://github.com/stars/obinexus/lists/the-rift-ecosystem" rel="nofollow">https://github.com/stars/obinexus/lists/the-rift-ecosystem</a></p>
<hr>
<p>Comments URL: <a href="https://news.ycombinator.com/item?id=45190796">https://news.ycombinator.com/item?id=45190796</a></p>
<p>Points: 2</p>
<p># Comments: 2</p>
]]></description><pubDate>Tue, 09 Sep 2025 23:15:46 +0000</pubDate><link>https://github.com/obinexus/rift</link><dc:creator>obinexus</dc:creator><comments>https://news.ycombinator.com/item?id=45190796</comments><guid isPermaLink="false">https://news.ycombinator.com/item?id=45190796</guid></item><item><title><![CDATA[Show HN: LibPolyCall – Zero-Trust Polyglot FFI with Perfect State Reproduction]]></title><description><![CDATA[
<p>Hi HN! I'm Nnamdi from OBINexus Computing. I've been working on LibPolyCall, a program-first protocol that eliminates language barriers in distributed systems.
The Problem: Every API needs separate implementations for Python, Node.js, Java, etc. This creates duplicate code, maintenance nightmares, and debugging hell across microservices.
Our Solution: LibPolyCall provides:<p>Single API definition → automatic polyglot implementations
Zero-trust security at the protocol level
Cryptographically-seeded GUIDs for perfect bug reproduction
Silent telemetry capturing every interaction
Hot-swappable adapters without downtime<p>Key Innovation: We've moved from "binding-first" to "program-first" architecture. Instead of writing language-specific bindings, you define your API once and LibPolyCall handles the translation.
Real Metrics:<p>Reduced integration time by 75% in pilot deployments
Zero-overhead FFI calls through direct memory mapping
100% state reproducibility for debugging
Supports Python, Node.js, Rust, Go (more coming)<p>Use Cases:<p>Legacy COBOL systems talking to modern microservices
Cross-language microservice communication
Unified telemetry across polyglot systems
Hot-swapping components without downtime<p>Currently in v1trial. Looking for feedback from teams dealing with polyglot complexity.
GitHub: <a href="https://github.com/obinexus/libpolycall" rel="nofollow">https://github.com/obinexus/libpolycall</a>
Docs: github.com/obinexus
/libpolycall/docs
Video Demo: ion<a href="https://youtube.com/@obinexus/playlists" rel="nofollow">https://youtube.com/@obinexus/playlists</a> (search libpolycall)
Happy to answer questions about the architecture, zero-trust implementation, or our approach to solving the polyglot problem!</p>
<hr>
<p>Comments URL: <a href="https://news.ycombinator.com/item?id=45190762">https://news.ycombinator.com/item?id=45190762</a></p>
<p>Points: 3</p>
<p># Comments: 0</p>
]]></description><pubDate>Tue, 09 Sep 2025 23:12:34 +0000</pubDate><link>https://github.com/obinexus/libpolycall</link><dc:creator>obinexus</dc:creator><comments>https://news.ycombinator.com/item?id=45190762</comments><guid isPermaLink="false">https://news.ycombinator.com/item?id=45190762</guid></item></channel></rss>