Home 01 Technology 02 Projects 03 Research 04 About 05 GitHub ↗ Contact FuryLogic

Software

Systems we build and operate.

Production software across inference, data, retrieval, networking, systems and tooling. Each entry names the technical focus, the license and the result that was measured — not a capability that was imagined.

Catalogue

11 projects

Showing all 11 projects

LLM Inference Engine MIT

Infernix

A pure-Rust inference engine with its own CUDA kernels.

One binary for NVIDIA GPUs, CPUs, ARM boards and phones. Infernix loads every GGUF weight type, serves an OpenAI-compatible API with tools and structured output, and implements its own dp4a and int8-MMA kernels rather than depending on cuBLAS or llama.cpp.

Focus
Batched decode across model families, expert placement for MoE models larger than VRAM, prefix caching for agent traffic, and speculative decoding.
Built with
Rust · CUDA · GGUF · OpenAI API
Measured
2.21× llama-server throughput at 64 concurrent users
Measured
35B MoE served on a single 8 GB GPU
Measured
28 ms cached 2.3k-token prompt on CPU
Unified Database Engine Apache-2.0

StrikeDB

One engine. Every data model.

A single storage substrate where relational tables, key-value, vectors, time-series, pub/sub, agent memory and RAG are views over the same engine — one consistency model, one license, one place for drift to hide instead of five.

Focus
MVCC and WAL storage, HNSW vector search with INT8 plus f32 rerank, a cost-based RAG planner, bi-temporal agent memory, and RESP wire compatibility.
Built with
Rust · RESP · HNSW · BM25 · MVCC
Measured
5.8× Redis SET and 3.9× GET throughput
Measured
0.995 recall@10 on 1M × 768-dimension vectors
Measured
310 tests; zero external crates
Search Infrastructure MIT

SearchOS

Self-hosted search for AI agents.

Full-text and vector retrieval over an index you own, fused with reciprocal rank fusion and rescored by a cross-encoder. Adds image search, federated peers, a polite recursive crawler, a live-web fallback cascade and an MCP server — with no per-query vendor.

Focus
Hybrid ranking, query-aware snippets, near-duplicate collapse, per-language full-text indexes, and measurable retrieval evaluation with nDCG, MRR and recall.
Built with
Python · FastAPI · PostgreSQL · pgvector · MCP · Redis
Measured
367-test suite across gateway, crawler and MCP
Measured
Cross-encoder reranking with an abstention check
Measured
MCP over stdio, SSE and Streamable HTTP
Fetch & Anti-Bot Gateway MIT

Proxify

An adaptive fetch gateway for the hostile web.

Escalates from TLS-impersonating HTTP clients to a persistent headful Chrome VM across eleven strategy tiers, so pages behind Cloudflare, Google and Reddit anti-bot walls come back as clean, LLM-ready markdown instead of a challenge page.

Focus
TLS fingerprint impersonation, per-domain strategy learning, session-cookie reuse, browser rendering only when cheaper tiers fail, and clean DOM-to-markdown extraction.
Built with
Python · FastAPI · curl_cffi · Chrome CDP · Redis
Measured
11-tier adaptive escalation pipeline
Measured
40+ TLS fingerprints; 42 CAPTCHA types bridged
Measured
L1 RAM + L2 Redis cache with circuit breakers
Decision Engine MIT

SyFox

State in. Typed decisions out. No text generation.

A dependency-free System One decision engine built on the Synthetic Intelligence physics substrate. Questions are read out of a settled energy field as typed answers — choice, score or boolean — with calibrated confidence and honest silence when nothing settles.

Focus
Bounded working sets, energy-gated readout, inspectable Hebbian lanes, deferred decisions that never guess, and a Jev-compatible HTTP surface.
Built with
C · Energy-field dynamics · HTTP · JSON
Measured
Zero runtime dependencies, fully offline
Measured
One settle pass per decision, not one pass per token
Measured
Choice, score and boolean question primitives
Agent Memory Service Apache-2.0

Memgent

Long-term memory for AI agents.

Turns conversations into durable, scoped memory stored in StrikeDB and served over MCP and REST. Facts are superseded rather than deleted, so “where does this work now” and “where did it work before” both have answers.

Focus
Hybrid dense, BM25 and entity recall with rank fusion, bi-temporal invalidation, graph links between facts and their sources, and stateless servers over a durable store.
Built with
Rust · StrikeDB · MCP · Model2Vec
Measured
~0.6 ms per search with the full pipeline
Measured
Zero external crates; offline embedding runtime
Measured
Scope isolation enforced server-side
AI API Gateway MIT

Chimera Gateway

One endpoint, many providers, one security boundary.

A self-hosted, OpenAI-compatible gateway with latency-aware routing, circuit breakers per provider and a defensive layer built around the “Your Agent Is Mine” threat model. A drop-in replacement for OpenAI and Anthropic clients with no code changes.

Focus
Provider fallback, WAF, prompt-injection detection, PII redaction, SSRF guards, request signing and a transparency log.
Built with
Python · FastAPI · AES-256-GCM · Docker
Measured
21 provider integrations behind one API
Measured
95 % test coverage on the gateway
Measured
Virtual models for auto, fast, quality and reasoning routing
Document Intelligence Apache-2.0

Lightning OCR

A production OCR hub with an agent-ready interface.

Multi-backend OCR across GLM-OCR, DeepSeek-OCR, Tesseract and EasyOCR with an automatic fallback chain, document-to-Markdown extraction for PDF and Office files, and both REST and MCP surfaces for agents.

Focus
Backend fallback, confidence-scored language detection, batch uploads, source-level Office extraction, and seven task-specific OCR modes.
Built with
Python · llama.cpp · Tesseract · MCP · Docker
Measured
Runs from a 4 GB CPU machine to an RTX 5090
Measured
PDF, image, SVG and Office document coverage
Measured
Stateless MCP 2026-07-28 transport plus legacy support
Visual Search MIT

Imify

Self-hosted reverse image search.

Finds where an image — or the person in it — appears online using your own index and your own verifiers, rather than trusting a vendor’s judgement. Candidates come from several engines; every match is checked locally before it is reported.

Focus
Perceptual hashing with rotation and mirroring, SIFT geometry, ArcFace faces, CLIP content similarity, OCR and a StrikeDB-backed image index.
Built with
Python · StrikeDB · CLIP · SIFT · ArcFace
Measured
Own image index on StrikeDB key-value and vectors
Measured
Multiple independent verification signals
Measured
No cloud account, no per-search fees
Kernel Runtime MIT

linux.js

The real Linux kernel, compiled to WebAssembly.

Compiles the Linux kernel through the Linux Kernel Library to WebAssembly, giving JavaScript a real VFS, scheduler and syscall surface without emulation, a container per tenant, or a server round-trip.

Focus
Library-mode sandboxing, real procfs and sysfs, file operations through actual kernel syscalls, and multi-runtime support with worker threads.
Built with
C · WebAssembly · LKL · Node.js
Measured
Kernel boots in roughly 0.6 s
Measured
Real syscalls, not a shimmed virtual filesystem
Measured
Node ≥ 18 with pthreads via worker_threads
Scientific Runtime AGPL-3.0

Matbox

A clean-room MATLAB-compatible runtime in Rust.

An independent reimplementation of the MATLAB language and runtime. Every value is a complex-valued N-dimensional array, every operation is vectorized, and the compute engine is entirely Rust — no Python, C++ or C.

Focus
Language semantics, N-dimensional array algebra, function handles and closures, a large builtin surface, and a language server.
Built with
Rust · N-dimensional arrays · LSP
Measured
437 passing tests, 325+ in the core language
Measured
MATLAB-compatible syntax and semantics
Measured
Pure Rust compute engine

Research code is not listed as product. Reference implementations that exist to support a paper are documented with the paper on FuryLogic Open Research, and are not presented as production software. Nothing here is a stub, a wrapper or a roadmap.

Source

Read the code behind the claims.

Canonical repositories are hosted on FuryLogic’s own Git service and mirrored to GitHub. Issues, patches and reproductions are welcome on either.

Next

Understand the research behind the systems.

FuryLogic Open Research collects the papers, the measured results and the limitations — including the work that has not succeeded yet.