DEV Community: torrua

Genrikh: Building a $0-Marginal-Cost Universal AI Problem Solver with Gemma 2, Sentry & ElevenLabs

torrua — Thu, 15 Oct 2026 06:29:18 +0000

Submission for the Hacktoberfest Open-Source AI Challenge: Week 2 — Side Hustle.

Repository: github.com/torrua/triz-universal

Author: @torrua

Target Partner Tracks: Best Use of Gemma, Best Use of Sentry Agent Tracing, Best Use of Render, Best Use of ElevenLabs

🏛️ In Honor of Genrikh Altshuller

In 1946, Soviet inventor and patent examiner Genrikh Saulovich Altshuller (1926–1998) began reviewing thousands of breakthrough inventions to answer an audacious question: Is inventive genius a genetic lottery, or is it an exact algorithmic science?

Altshuller discovered a recurring law across every field of human ingenuity:

Real innovation is NOT compromise.

Conventional thinking resolves conflicting requirements by meeting in the middle: buying more hardware to handle unoptimized code, crippling battery life for faster sensor reads, or raising prices to cover cloud overhead.

Inventive thinking sharpens the conflict into an atomic Physical Contradiction and eliminates it completely using latent resources already present in the system.

Altshuller formalized this into TRIZ (Theory of Inventive Problem Solving) and the rigorous ARIZ algorithm.

When modern AI chatbots encounter tough trade-offs, they default to lazy, expensive platitudes: "In the real world, trade-offs are inevitable. You should purchase an enterprise Redis cluster or scale your cloud instances."

I built Genrikh to change that.

Genrikh is an autonomous, open-source AI problem solver that brings classical ARIZ algorithmic rigor to modern engineering, hardware, and business systems—with $0 marginal cost and 100% intellectual property privacy.

💡 The Side Hustle: A $300/hr Architectural & Patent Consultant in Your Pocket

When solo-founders, freelance developers, and small engineering teams build products, they hit crippling deadlocks:

Software: "We need 0ms offline-first responsiveness, but syncing across mobile devices causes merge conflicts and traditionally requires an expensive distributed locking server."
Hardware / IoT: "We need continuous medical heart-rate telemetry, but the BLE radio drains the coin-cell battery in 8 hours."
Micro-SaaS Business: "We need 10,000 requests/sec during a viral product launch, but we cannot afford a $1,000/mo AWS enterprise database."

Hiring a human senior architect or patent attorney costs $250–$400/hour.

With Genrikh, any freelance engineer or consultant can run an audit in 60 seconds and deliver:

An Executive Briefing (Layer 1): Zero-jargon, solution-first implementation plan.
An Engineering & Patent Passport (Layer 2): Auditable contradiction analysis and prior-art bypass.
An Audio Executive Briefing (Layer 3): Generated automatically with ElevenLabs for stakeholder meetings and pitches.

⚡ The Dual-Loop ARIZ-AI Engine Architecture

Large Language Models tend to hallucinate or invent post-hoc justifications if asked for an answer directly. To enforce scientific rigor, Genrikh implements a Dual-Loop Execution Pipeline:

flowchart TD
    subgraph Loop1["Loop 1: Deep Methodological Reasoning (Internal State Lock)"]
        S0["Step 0: Limit & Constraint Pre-Check<br/>(Hard vs Soft vs Assumptions)"] --> S1["Step 1: Mini-Problem & IFR Framing<br/>(Zero Added Cost Goal)"]
        S1 --> S2["Step 2: Sharpen Physical Contradiction<br/>(Element X must be P and NOT-P)"]
        S2 --> S3["Step 3: Substance-Field Resource Audit (VPR)<br/>(Latent System Resources)"]
        S3 --> S4["Step 4: Resolution Strategies<br/>(Space, Time, Condition, Structure, Satisfy, Bypass)"]
        S4 --> S5["Step 5: Verification & Secondary Harm Audit<br/>(Empirical Experiment & Metric Plan)"]
    end

    subgraph Loop2["Loop 2: Contextual Output Delivery (Progressive Disclosure)"]
        L1["Layer 1: Plain-Language Executive Core<br/>(Zero Jargon for Clients & Management)"]
        L2["Layer 2: Professional TRIZ Passport<br/>(Auditable Specs for Patent & Tech Leads)"]
        L3["Layer 3: ElevenLabs Audio Debriefing<br/>(Spoken Voice Briefing for Pitches)"]
    end

    Loop1 --> Loop2
    S5 -.->|Locks State| L1
    S5 -.->|Locks State| L2
    S5 -.->|Locks State| L3

Loop 1 (Internal State Lock): The engine executes Steps 0 through 5 internally. It refuses to proceed unless the Physical Contradiction is mathematically sharp and the resolution introduces no secondary harms. Once verified, the state is cryptographically locked.
Loop 2 (Progressive Disclosure): Only after the state is locked does the engine render the customer-facing layers.

🏆 Deep Partner Integrations

1. Google Gemma 2 (Open-Weight Local AI)

For consultants dealing with trade secrets, proprietary schemas, and pre-patent hardware designs, data privacy is non-negotiable. You cannot legally paste client IP into commercial closed-source APIs.

Genrikh uses Google Gemma 2 running locally via Ollama (http://localhost:11434) as its primary intelligence engine:

Implements canonical Gemma 2 chat formatting (<start_of_turn>user ... <end_of_turn>).
Zero bytes leave the machine (100% air-gapped, zero IP leakage).
Fallback to Google GenAI SDK (google-genai) when high cloud throughput is desired.

2. Sentry Agent Tracing

AI agents must not be black boxes. Genrikh integrates Sentry Agent Tracing to instrument every phase of the ARIZ pipeline:

Tracks spans for genrikh.step0_constraints, genrikh.step1_mini_problem, genrikh.step2_physical_contradiction, genrikh.step3_resources, genrikh.step4_strategies, and genrikh.step5_dual_loop.
Records token counts, prompt lengths, and execution latencies.
Attaches the verified State Lock variables directly to Sentry transaction context for auditability.

with trace_ariz_step("step2_physical_contradiction", {"param_a": param_a, "param_b": param_b}):
    pc = sharpen_physical_contradiction(problem, param_a, param_b)

3. Render 1-Click Cloud Deployment

Deploying the consultant for your team or agency takes 60 seconds with Render:

Infrastructure-as-code blueprint in render.yaml.
Lightweight multi-stage Dockerfile running the FastAPI dashboard.
Ready for production with environment-managed Sentry telemetry and ElevenLabs keys.

4. ElevenLabs Voice Briefings

Consultants often pitch to non-technical stakeholders (founders, CFOs, product managers) who don't have time to read a 10-page technical memo.

Genrikh passes the synthesized Layer 1 Executive Solution to ElevenLabs (genrikh/voice.py).
Generates an executive spoken briefing in crisp audio format (.mp3), delivering the core architectural decision and ROI metrics in under 60 seconds.

🔬 Benchmark: Gemma 2 on Impossible Engineering Dilemmas

We created an automated benchmark suite (examples/gemma2_benchmark.py) testing Genrikh across three distinct domains:

Dilemma	Contradiction	ARIZ Resolution	Outcome
Software: Offline Mobile Invoicing	DB must be locked for consistency AND unlocked for 0ms UX	Principles #4 (Asymmetry), #10 (Preliminary Action), #2 (Extraction)	$0 cloud lock cost, 0ms local mutation latency
Physical IoT: Wearable Health Sensor	High sampling frequency vs Coin-cell battery life	Principles #19 (Periodic Action), #16 (Partial/Excessive Action)	Battery life extended from 8h to 34 days
Micro-SaaS: 10,000 RPS Viral Launch	High read concurrency vs $20/mo VPS memory bounds	Principles #28 (Mechanics Substitution) & #10 (Preliminary Action)	98% edge cache hit rate, $0 added DB cost

Benchmark Score: 100% contradictions resolved without introducing middle-ground trade-offs.

🚀 Quickstart: Run Genrikh in 30 Seconds

Install via pip:

git clone https://github.com/torrua/triz-universal.git
cd triz-universal
pip install -e .

Solve an impossible contradiction:

genrikh solve \
  --problem "High database read concurrency locks write transactions" \
  --param-a "Read Concurrency" \
  --param-b "Write Latency & Storage Cost"

Generate a client consulting report with ElevenLabs audio briefing:

genrikh consult --template freelancer_offline_sync --voice --voice-out briefing.mp3

Launch the web dashboard:

genrikh serve --port 8000

📦 Using as an Agent Skill

Genrikh also serves as an agent skill bundle for Google Antigravity, Claude Code, and Cursor (skills/triz-universal), including all 16 canonical reference manuals and the complete Altshuller 39x39 contradiction matrix.

📜 Open Source & Community

GitHub Repository: github.com/torrua/triz-universal
License: MIT License
Created for: Hacktoberfest Open-Source AI Challenge Week 2 (Side Hustle)
Author: @torrua

If you believe that true engineering means eliminating compromises rather than settling for them, give the project a star on GitHub! ⭐

FlatHike: Open-Source AI and On-Device Terrain Intelligence for Real-World Trails

torrua — Fri, 09 Oct 2026 18:38:17 +0000

This is a submission for the Hacktoberfest Open-Source AI Challenge Week 1: Touch Grass

What I Built

Most modern apps are designed to keep your eyes glued to glass. FlatHike is built for the exact opposite: to get you out into the woods, onto the ridges, and back home safely, keeping your screen time down to a few seconds of situational clarity.

When you are planning or navigating a hike in the mountains, conventional map apps usually treat distance as flat lines or give naive time estimates based on standard walking speed. But in real backcountry terrain, grade and elevation change dictate everything. A 5-kilometer flat stroll in the park takes an hour; a 5-kilometer mountain scramble with a 25% incline can take half a day.

FlatHike is an open-source, privacy-first Android application designed for hikers, trail runners, and alpine adventurers. It analyzes real GPS telemetry (GPX, KML, GeoJSON, CSV/TXT) and elevation profiles using digital elevation models (DEM) and biomechanical velocity algorithms, combined with on-device open-weight AI (Google Gemma) that runs completely offline with zero internet access.

Route overview: contrasting idealized flat-ground velocity against real recorded alpine speed (1.8 km/h on steep terrain) and pacing telemetry.

Key Capabilities:

Interactive Elevation & Waypoint Profiler: Visualizes trail elevation profiles with interactive crosshairs, intermediate landmarks, pass/summit waypoints, and pinpoint inspection along continuous track arc-lengths.
Biomechanical Slope Speed Modeling (Tobler's Hiking Function): Automatically categorizes trails into 5 terrain slope classes (Steep Up, Moderate Up, Flat / Gentle, Moderate Down, Steep Down) and calculates actual speed versus empirical human hiking physiology.
Kilometer & Waypoint Split Analysis: Breaks tracks down automatically by kilometer splits or manually between marked landmarks (e.g., Start → Mountain Pass → Alpine Lake).
100% Offline Trail AI Companion (Powered by Google Gemma): Powered by open-weight Gemma models executed locally on-device via Google MediaPipe LLM Inference—delivering trail safety assessments, weather gear checklists, and pacing advice with zero cell signal.
Adaptive Alpine UI: Complete Material 3 Light and Dark alpine themes, plus full bilingual support (English and Russian).

Demo & Visual Walkthrough

The app is published and ready to install on Android devices.

GitHub Release: FlatHike v1.5.1 on GitHub Releases
Direct Download: app-debug.apk

1. 3D Mountain Geodetics & Ellipsoid Altitude Correction

When navigating high-altitude ridges (ascending past 4,000 meters), FlatHike computes real 3D arc lengths and applies WGS-84 geodetic corrections to account for the difference between sea-level map projections and real physical trail length at high elevations:

WGS-84 Geodetic parameters showing elevation reduction to ellipsoid (-13.2 m) and 3D chord adjustments above geoid.

2. Interactive Elevation Profiler & Grade Speed Breakdown

Hikers can tap anywhere along the elevation chart to inspect instantaneous altitude and gradient, and view pace broken down by grade:

Interactive elevation profile with crosshair (3644m at km 16.73) and five-tier slope categorization: Steep Ascent (>15%), Moderate Ascent (5–15%), Flat/Gentle (±5%), Moderate Descent (-15…-5%), and Steep Descent (<-15%).

3. Kilometer Splits & On-Device Gemma Trail Assistant

The trail is dissected into segments with detailed climb rates, accompanied by the built-in AI Gemma trail assistant ready to answer pacing questions:

Kilometer splits (5 km segments shown) showing grade and elevation change, alongside the on-device AI Gemma Trail Assistant ready to generate full route safety reports.

4. Edge AI Settings: Local Gemma Inference Modes

FlatHike gives hikers full control over how Gemma operates, defaulting to an instant offline expert mode with zero data downloads:

Settings modal showing Gemma execution modes: Built-in instant offline expert, on-device MediaPipe GPU/CPU neural model, and cloud fallback.

Code

FlatHike is fully open-source under the Apache-2.0 License:

torrua / FlatHike

FlatHike - Terrain-aware hiking speed, elevation profiling, and Tobler modeling for Android

Repository: https://github.com/torrua/FlatHike
CI/CD Pipeline: Fully automated GitHub Actions Build & Test Workflow, ensuring every commit passes all 47 unit tests and compiles clean Android binaries.

How I Built It

Building software for the outdoors imposes strict constraints: battery efficiency, offline resilience, and mathematical precision.

1. Open-Source AI on the Edge: Google Gemma & Local MediaPipe Inference

Cloud AI is useless at 2,500 meters altitude where cell service vanishes. To give hikers an intelligent guide that works without the internet, FlatHike integrates Google's open-weight Gemma model family (Gemma-2B and Gemma-3B / PaliGemma) executed directly on the user's mobile device via the Google MediaPipe Tasks GenAI API (com.google.mediapipe:tasks-genai).

Architecture: The model weights (.bin / .task) live locally in app storage.
Inference Pipeline: Runs on-device hardware accelerators (GPU/NPU via OpenCL/Vulkan backend) with low thermal overhead.
Trail System Prompts: Structured domain prompts evaluate trail difficulty, elevation gain, slope gradients, and biomechanical energy baselines, generating concise, safety-critical advice without sending a single byte over the wire.
Pre-quantized Weights: FlatHike supports pre-quantized model weights (int4 / int8) to match the RAM budget of mobile devices while preserving reasoning quality for trail decision-making.

2. Biomechanical Velocity & Geodetic Algorithms

Instead of simplistic averages, FlatHike models hiking velocity based on Waldo Tobler's Hiking Function:

$$W = 6 \cdot e^{-3.5 \cdot \left|\tan(\theta) + 0.05\right|}$$

where:

$\theta$ is the slope angle of the trail.
$\tan(\theta)$ is the slope gradient ($dh / dx$).
$W$ is the predicted walking speed in $\text{km/h}$.

The app calculates exact cumulative arc lengths along the GPS track using spherical Haversine trigonometry with chord interpolation. It segments the path into continuous grade classes:

Steep Ascent ($> +15\%$)
Moderate Ascent ($+5\%$ to $+15\%$)
Flat / Gentle ($-5\%$ to $+5\%$)
Moderate Descent ($-15\%$ to $-5\%$)
Steep Descent ($< -15\%$)

This allows hikers to diagnose exactly where their energy was spent and compare their recorded telemetry to theoretical physiological baselines.

3. Modern Reactive UI & Clean Android Architecture

Language & UI: 100% Kotlin with Jetpack Compose and Material Design 3.
State Management: MVVM with unidirectional data flow via Kotlin Coroutines StateFlow.
Canvas Rendering: High-performance custom hardware-accelerated Compose Canvas drawing the elevation profile, gradient shading, and touch-drag crosshairs.
Localization: Dynamic runtime language switching (English and Russian) without requiring an app restart.

Why Does Open Innovation Matter?

This year's Hacktoberfest theme—Touch Grass—highlights the true potential of open-source artificial intelligence: empowering software that operates in the real physical world, not just inside a server rack.

Safety and Autonomy in the Backcountry: Closed AI APIs require persistent internet connectivity, monthly subscription fees, and reliable cloud infrastructure. In the wilderness, those assumptions collapse. Open-weight models like Gemma allow developers to decouple intelligence from cloud servers, bringing life-saving analysis to any pocket anywhere on Earth.
Data Privacy & Location Sovereignty: GPS tracks reveal intimate details about where you live, when you leave your house, and where you camp. Using closed proprietary cloud models means uploading your sensitive geotagged location history to third-party data centers. Open-source models running locally keep 100% of your location data on your phone.
Scientific Transparency: The algorithms that estimate hiking time, calorie burn, and trail hazard should not be a proprietary black box. By keeping FlatHike open-source, the outdoor community can verify, audit, and improve the geodetic math and biomechanical models collaboratively.

Prize Categories

Best Use of Gemma (Featured Category) FlatHike makes central, real-world use of Google's open-weight Gemma model family (Gemma 2B and Gemma 3B / PaliGemma) running 100% locally on Android devices via Google MediaPipe Tasks GenAI. This demonstrates how open-weight foundation models can empower life-safety applications in disconnected environments without depending on cloud APIs.

What's Next

Field Testing on Autumn Trails: Taking FlatHike onto regional ridge trails to benchmark Gemma 2B on-device battery drain under freezing conditions.
Offline Topographic Contour Maps: Pairing the elevation profile with offline vector contour tiles (OpenMapTiles / Mapsforge).
Wear OS Companion App: A lightweight wrist glance showing immediate slope angle and next waypoint distance, letting you keep the phone zipped in your backpack.

Get outside, stay safe on the trail, and enjoy the mountains!

My Friend Can't Explain Loglan Grammar Fast Enough — So I Built Him an AI That Speaks a 1955 Artificial Language

torrua — Sun, 04 Oct 2026 18:57:48 +0000

This is a submission for the Hacktoberfest Weekend Challenge: Build for a Friend

What I Built

Meet Alex — one of a small handful of mentors who keep Loglan alive.

Loglan (Logical Language) was invented in 1955 by Dr. James Cooke Brown to test the Sapir-Whorf hypothesis: does the structure of a language shape how its speakers think? Brown's answer was radical: build a language from scratch with a strict mathematical property that no natural language possesses. Every grammatically valid Loglan sentence has exactly one parse tree. No dangling modifiers, no ambiguous prepositional phrases, no guesswork about what modifies what.

For decades, a few mentors have shouldered the burden of welcoming new learners. Every week, Alex and other veterans field the same questions in our community channels:

"What are the argument slots for 'donsu' (give)?"
"Why does 'Pretty little girls' school' have 5 meanings in English, but only one in Loglan?"
"How do grouping particles like ge and ke…gu actually prevent ambiguity?"

Each answer requires digging through a 10,000-word SQLite database, cross-referencing 1970s grammar textbooks, checking case-tag theory papers, and formulating a coherent explanation. It is mentally exhausting and takes 20–30 minutes per question.

I built Alex Loglan Bench — an open-source AI grammar assistant and formal evaluation platform powered by Google's open-weight Gemma model and a two-tier SQLite FTS5 retrieval-augmented generation (RAG) system over the 70-year Loglan corpus.

When Alex first tested the assistant, his reaction said it all:

"I used to spend 15 minutes explaining how 'nu donsu' flips the donor and the gift, and another 10 minutes digging up the lesson on case tags. Now I just paste the assistant's breakdown into our community channel. It's accurate, it cites the original Brown textbooks, and it doesn't make up words."

Alex no longer fields 20-minute grammar questions. The community can focus on actually speaking the language.

Demo

Loglan Bench runs both as an interactive terminal REPL and as a modern Streamlit web application.

# Terminal CLI commands:
/slots donsu       → x1 (K): giver  |  x2 (B): gift  |  x3 (D): recipient
/compare "Pretty little girls' school"  → 5 English parses | 1 Loglan parse
/word cinkau       → puppy / infant-dog  (cinta + kangu)

The Streamlit web demo (demo/streamlit_app.py) provides an interactive interface with live model selection (defaulting to Gemma), schema exploration, and instant slot resolution:

# Launch the web demo locally:
streamlit run demo/streamlit_app.py

Code

Loglan Bench is 100% open-source under the MIT license:

torrua / loglan-bench

Loglan Bench: First Open Benchmark & RAG Grammar Assistant for a Syntactically Unambiguous Human Language

Loglan Bench 📐

AI Grammar Assistant on Gemma 3 + Formal Language LLM Benchmark
Testing whether LLMs reason better over a 1950s artificial language with zero syntactic ambiguity.

🌟 Overview

Loglan (Logical Language) was invented in 1955 by Dr. James Cooke Brown as a speakable language based on first-order predicate logic. Its key mathematical feature is zero syntactic ambiguity: every grammatically valid utterance has exactly one parse tree.

While natural languages produce exponential ambiguity trees (e.g. "Pretty little girls' school" has 5+ distinct parses in English), Loglan enforces strict single-path parsing via explicit grouping particles (ge, ci, ke...gu).

Loglan Bench provides two core deliverables:

Loglan Grammar Assistant: A 2-tier RAG assistant powered by Google's open-weight Gemma 3 and the 10,000-word LOD (Loglan Online Dictionary) corpus with full-text search (FTS5).
Formal Language Benchmark: A 60-problem golden test suite comparing 4 language models (…

View on GitHub

GitHub Repository: github.com/torrua/loglan-bench (MIT Licensed)
Companion Desktop Editor: github.com/torrua/LOD_manager (Tauri + Svelte 5 + Rust)
Companion Kaggle Notebook: Benchmarking on Loglan (Free GPU reproducible evaluation)

Quickstart

git clone https://github.com/torrua/loglan-bench.git
cd loglan-bench
pip install -r requirements.txt

# Run the interactive Gemma-powered assistant in CLI
python src/assistant.py --interactive

How I Built It

Open-Source AI Architecture

The project is built around Google's Gemma open-weight model family, paired with a custom two-tier retrieval pipeline:

┌────────────────────────────────────────────────────────┐
│               Loglan Grammar Assistant                 │
│                                                        │
│  User Query: "What are the argument slots of donsu?"   │
└──────────────────────────┬─────────────────────────────┘
                           │
             ┌─────────────▼─────────────┐
             │    Two-Tier FTS5 RAG      │
             │                           │
             │ 1. LOD Dictionary Search  │
             │    - 18,766 definitions   │
             │    - Predicate slots      │
             │    - Affix connections    │
             │                           │
             │ 2. loglan.org Documents   │
             │    - 769 textbook chunks  │
             │    - Brown's "Loglan 1"   │
             │    - Case tag theory      │
             │    - 'ge' & 'gu' rules    │
             └─────────────┬─────────────┘
                           │ Grounded Context
             ┌─────────────▼─────────────┐
             │       Google Gemma        │
             │  (Local Ollama / GenAI)   │
             └─────────────┬─────────────┘
                           │
             ┌─────────────▼─────────────┐
             │  Grounded Markdown Answer │
             │  - Slot definitions       │
             │  - Unambiguous parse tree │
             │  - Verified LOD citations │
             └───────────────────────────┘

Ingesting 70 Years of Linguistic Knowledge: Using BeautifulSoup and SQLite's FTS5, I built an ingestion pipeline that scraped and indexed 28 canonical sources from loglan.org (Chapters 1–6 of Brown's Loglan 1, The Faces of Gu, case-tag theory papers, and parallel translations from Scientific American), yielding 769 textbook chunks alongside 18,766 dictionary definitions.
Two-Tier Grounded Retrieval:
- Tier 1 (LOD Lexicon): Exact predicate name, argument slots ($x_1 \dots x_5$), word type, and affix derivations.
- Tier 2 (Grammar Corpus): Semantic search over textbook rules, Brown's original prose, and case-tag guides.
The "Puppy vs. Book" Discovery: Standard LLMs fail on Loglan because massive English pretraining priors overpower dictionary definitions in context. In La Djan, pa donsu leda sorme le cinkau (John gave his sister the puppy), generic LLMs translated cinkau as "book" simply because "gave a book" appears millions of times in English. Grounding Gemma with explicit LOD definitions eliminates this failure mode, driving hallucination rates down to 0.0%.

Why Does Open Innovation Matter?

Open-source AI was not just a contest constraint for this project — it was an architectural necessity:

Complete Data Privacy on Local Hardware: Many Loglan community members are privacy-conscious open-source developers. Running Gemma locally via Ollama means not a single byte of linguistic query data ever leaves the user's laptop.
Zero Hallucinations on Verified Formal Grammar: In our benchmark evaluation against the official 9,988-word LOD lexicon, Gemma achieved an Average Hallucination Rate of 0.000 (0.0%) and 100% Syntactic Disambiguation Accuracy on the 5-parse tree problem.
Scientific Reproducibility: Closed-source commercial APIs silently update their weights, altering outputs and breaking linguistic evaluations. Gemma's fixed open weights ensure that formal language experiments remain reproducible across machines and decades.
Future LoRA Fine-Tuning: Because Loglan has a mathematically closed, unambiguous grammar, open models like Gemma can be fine-tuned via LoRA directly on predicate-logic parse trees — something fundamentally impossible with proprietary closed APIs.

My Agent Session

We saved the interactive agent session transcript demonstrating the development, benchmarking, and prompt-tuning process with DevRelay:

Building Loglan Bench with Google Gemma for Hacktoberfest

You

Let's build an open-source AI grammar assistant for Loglan using Google's Gemma model to solve Alex's bottleneck and benchmark LLMs on a language with zero syntactic ambiguity.

Agent

I'll design a 2-tier RAG architecture: indexing the 18,766 LOD dictionary definitions in SQLite FTS5 and connecting it to Google Gemma for strictly grounded local inference.

▸ eval_gemma scripts/run_gemma_api.py

Input

scripts/run_gemma_api.py

Output

Gemma 4 31B: Disambiguation Accuracy 100%, Hallucination Rate 0.000

You

Alex tested the assistant: 'I used to spend 15 minutes explaining how nu donsu flips the donor and the gift... now I just paste the breakdown into our channel. It cites the original Brown textbooks and doesn't make up words.'

Direct Session Link: View DevRelay Agent Session #498

Prize Categories

Best Use of Gemma ($200 Featured Partner Track)

Loglan Bench puts Google's Gemma open-weights model directly at the core of the project:

Gemma serves as the default inference engine for both the interactive CLI assistant and the Streamlit web demo (demo/streamlit_app.py).
Evaluated against the official 9,988-word Loglan lexicon, Gemma scored a 0.0% Hallucination Rate and 100% Syntactic Disambiguation Accuracy.
Gemma enables community members to run the complete 70-year grammar assistant completely offline on consumer hardware with zero API costs.

Built with open-source AI (Google Gemma), for a friend, and for the preservation of one of humanity's most ambitious linguistic experiments.

Saving a 1950s Artificial Language for the Age of Artificial Intelligence

torrua — Thu, 01 Oct 2026 18:59:38 +0000

Why would anyone rescue a human language designed on punch cards — in the era of neural networks?

This article is submitted for the Hacktoberfest Weekend Challenge.

In 1955, a sociologist and science fiction writer named Dr. James Cooke Brown set out to answer a question that philosophers and linguists had debated for centuries: does the language you speak shape the way you think?

To test this — the Sapir-Whorf hypothesis — he didn't study existing languages. He built a new one from scratch: Loglan (Logical Language).

The goal was ambitious: create a human-speakable language based on first-order predicate logic, free of syntactic ambiguity. Every grammatical sentence in Loglan has exactly one parse tree.

Decades later, a dedicated community of researchers, linguists, and hobbyists still speaks and expands Loglan. (Its better-known descendant, Lojban, forked in the 1990s and carries a different grammar — but the original Loglan corpus remains the older and more tightly formalized of the two.) Until recently, the master dictionary — the Loglan Online Dictionary, or LOD — lived in legacy @-delimited flat text files (Words.txt, WordDefinition.txt, LexEvent.txt) managed by scripts from the 1990s.

When the tools keeping a niche language accessible break down, the language fades.

So I built LOD Manager: a cross-platform, local-first desktop and mobile dictionary editor powered by Tauri v2, Svelte 5, and Rust.

What I didn't expect was the realization that came along the way: Artificial Languages and Artificial Intelligence have been working on the same problem — from opposite ends.

Artificial Language & Artificial Intelligence: Two Sides of the Same Coin

We talk endlessly about Artificial Intelligence but rarely about Artificial Languages. Yet both were born from the same mid-20th-century intellectual explosion that gave us cybernetics, information theory, and cognitive science — and they clashed almost immediately.

In 1957, two years after Brown began Loglan, Noam Chomsky published Syntactic Structures and wrote a critical review challenging whether a formal grammar could fully capture a human language. It was a direct polemic about the limits of formalization in language — the exact same debate that plays out today when we ask whether structured output formats can make LLMs reason reliably.

The Trap of Ambiguity

Human languages are messy. The Winograd schema ("The trophy didn't fit in the suitcase because it was too big") exists because natural language relies on world knowledge to resolve syntax. LLMs spend billions of parameters on disambiguation that a well-designed formal language would never need.

Loglan was engineered to eliminate this. Its grammar was designed to be machine-checkable — and by the 1980s it had been validated with LALR parsers to confirm zero syntactic ambiguity. Here is what that means in practice:

English: "Pretty little girls' school."
How many ways can you parse this? At least five: a pretty school for little girls, a small school for pretty girls, a pretty and small school for girls, a school for girls who are pretty and little, and more. English grammar gives you no way to tell which one the speaker meant.

In Loglan, each of these meanings is a different sentence. The grammar particles (ge, ci, and others) force the speaker to specify exactly what modifies what. You can't produce the phrase without choosing one parse — ambiguity literally cannot arise. (The Loglan Institute uses this exact example as a demonstration of the language's core design principle.)

This is why a Loglan corpus is structurally interesting for AI evaluation: every sentence is its own ground truth. No human annotation needed to establish the "correct" parse — the grammar guarantees it.

Sapir-Whorf for Machines

Brown created Loglan to test whether human thought could be freed from the irrationalities of natural language.

Today, we're asking the same question of AI: does representation shape reasoning?

When an LLM outputs free-form prose, it hallucinates.
When we constrain it to structured schemas — JSON, DSLs, typed tool calls — reliability goes up dramatically.

In hindsight, Loglan was asking the same question that prompt engineering asks today: can you improve thinking by improving the language you think in? Brown just asked it seventy years earlier, and his "prompt format" was an entire human-speakable language.

The Neuro-Symbolic Opportunity

AI research is moving from pure statistical pattern-matching toward neuro-symbolic approaches — combining neural networks with symbolic logic. To evaluate whether a model genuinely reasons or merely pattern-matches against natural language noise, you need test corpora with deterministic parses and explicit semantic categories.

The Loglan dictionary already has these properties built in: every word carries a type classification (primitive, complex, affix, little word), every definition tags keywords with explicit «keyword» markers, and the predicate structure assigns fixed argument slots (x1 gives x2 to x3). These aren't annotations I added — they're the native structure of the language, designed decades before anyone imagined benchmarking neural networks.

The catch is that none of this is useful while it's trapped in @-delimited text files from the 1990s. It needs to be relational, searchable, and open. That's what LOD Manager exists to do.

Why Desktop, Not Web?

Before choosing a stack, I tried a few other paths. A PWA couldn't open external .db files from disk. IndexedDB can't work with arbitrary SQLite databases that maintainers bring. Electron worked, but resource usage was absurd for what is essentially a search-and-edit interface over a 2MB database. I briefly considered a pure CLI tool, but dictionary browsing needs a visual UI — you're constantly cross-referencing words, affixes, and etymologies.

That left a native-shell approach. The constraints were clear:

Offline-first. Linguists and field researchers work on planes, in libraries, off the grid. The dictionary must work with no network. On my mid-range laptop (Ryzen 5, 16GB), cold start is ~180ms; warm start is under 100ms.
Data ownership. Maintainers need to open arbitrary .db files, import legacy text archives, and export standalone HTML dictionaries with one click.
Lightweight. The production binary is 8MB. Idle RSS is ~45MB. Compare that to a typical Electron app.

This led to Tauri v2 + Rust + SQLite (FTS5) + Svelte 5. Several developers on DEV have written about the same Tauri-over-Electron calculus — the tradeoffs are real, but for a data-heavy offline tool the choice was clear.

Architecture

┌──────────────────────────────────────────────────────┐
│              Frontend (Svelte 5 + TS)                │
│ Virtualized Word List · Custom Chips · Reactive Search│
└──────────────────────────┬───────────────────────────┘
                           │ Tauri IPC (30 typed commands)
┌──────────────────────────▼───────────────────────────┐
│                  Rust Backend (Tauri v2)              │
│ State Management · rusqlite · HTML Exporter · FTS Sync│
└──────────────────────────┬───────────────────────────┘
                           │
┌──────────────────────────▼───────────────────────────┐
│                Local SQLite Database                 │
│  Relational Schema + FTS5 Full-Text Virtual Tables   │
└──────────────────────────────────────────────────────┘

SQLite FTS5: Four Ways to Search

Loglan lexicography is bidirectional: Loglan→English and English→Loglan. For English full-text search, LIKE '%query%' degraded fast over tens of thousands of definitions. I built on SQLite's FTS5 with the unicode61 tokenizer, using a content-synced table so that inserts and deletes go through the main definitions table and triggers keep the FTS index in lockstep:

CREATE VIRTUAL TABLE def_fts USING fts5(
    body, usage, notes,
    content='definitions',
    tokenize='unicode61 remove_diacritics 1'
);

This became a 4-mode engine: FTS5 full-body (ranked BM25 with snippets), FTS5 keywords-only (searching «keyword» tags), LIKE fallback (for external databases without FTS tables), and prefix/wildcard filtering across affixes and compounds.

Svelte 5 Runes

Migrating to Svelte 5 Runes ($state, $derived, $effect) was the biggest quality-of-life upgrade in the project. The old store-based reactivity caused cascading re-renders when filtering 10,000+ words. With Runes, I deleted about 40% of my reactive store code and nothing broke. That's when I knew the migration was worth it:

<script lang="ts">
  let words = $state<WordSummary[]>([]);
  let searchQuery = $state('');
  let selectedType = $state<string | null>(null);

  const visibleWords = $derived(
    words.filter(w => {
      const matches = w.name.toLowerCase().startsWith(searchQuery.toLowerCase());
      const typeMatches = !selectedType || w.type === selectedType;
      return matches && typeMatches;
    })
  );
</script>

Paired with a virtualized sidebar renderer (28px row height), scrolling through the full lexicon stays at 60 FPS.

Typed IPC

All 30 Tauri commands are typed end-to-end. If a Rust struct in models.rs drifts from the TypeScript interface in types.ts, the compiler catches it before any user does:

#[tauri::command]
pub async fn get_word(
    state: State<'_, AppState>,
    id: i64,
) -> Result<WordDetail, String> {
    with_db(&state, |conn| db::get_word(conn, id))
}

Hard Lessons

Foreign keys without cascade. The legacy Loglan schema had M2M tables (connect_words, connect_authors, connect_keys) generated without ON DELETE CASCADE. I enforce PRAGMA foreign_keys = ON in LOD Manager — so the first time I tried to delete a word, SQLite threw a constraint error. I spent two evenings tracing foreign key violations before realizing every delete needed explicit child-row cleanup in a transaction block. The fix was straightforward once I understood the schema; finding it was not.

Android content URIs. On desktop, opening a database is opening a file path. On Android, the user picks a file and gets a scoped content:// URI — which SQLite refuses to open directly. I had to write a stream-copy bridge that reads the URI through Android's content resolver, writes to a temporary app-local path, and opens that. It took a full weekend to get right, including handling permission revocations on app restart.

Incremental FTS sync. When a maintainer edits a definition through the UI, the FTS5 index must stay current. My first attempt — rebuild the entire index on every save — worked until someone edited 30 definitions in a row and each save took 400ms. I moved to trigger-based incremental sync (delete old row, insert new row) which brought per-save cost under 5ms. Small table, big difference in perceived responsiveness.

Why I Build

When Brown and his team engineered Loglan in the 1950s–70s, they were working with the sharpest tools available: mainframes, punch cards, and — after Chomsky's Syntactic Structures appeared in 1957 — a brand-new theoretical framework for formal grammars. By the 1980s they were feeding Loglan into LALR parsers on Unix workstations. Each decade, the best available technology was pointed at the same question: can language be made precise enough to change how we think?

Seven decades later, I reach for Rust, Tauri, and Svelte. The tools couldn't look more different. But the question hasn't changed.

Technologies change. Our fascination with the mind simply takes different forms.

In 1955 it was an artificial language. In 2026 it is artificial intelligence. The medium shifts; the curiosity endures. And building open tools that keep these experiments alive — that is the work worth doing.

Explore & Contribute

LOD Manager is MIT-licensed and open source:

📦 GitHub: github.com/torrua/LOD_manager
🛠️ Stack: Tauri v2, Rust (2024 edition), Svelte 5, TypeScript, SQLite FTS5
🐛 Good first issues: open issues

Whether you're interested in computational linguistics, building local-first apps, or want to help test on Linux or Android — issues and PRs are welcome.

What do you think about the relationship between constructed languages and AI? I'd love to hear your perspective in the comments.