Jargonaut: Universal Language Interpretation Platform
Inspiration~
Language has always been a double-edged sword. While specialized vocabularies allow experts to communicate with extreme precision, they also build invisible walls that exclude the public.
A patient receives a medical report reading "Idiopathic Myocardial Infarction" and feels only panic. A startup founder tries to navigate a contract laden with "Force Majeure" clauses and dense legal jargon. A student struggles to read medieval texts, biblical passages, or internet subculture slang.
I realized that current translation tools are built for converting one national language to another (e.g., English to Spanish), but nothing was built to translate language within a language, moving from impenetrable complexity to everyday clarity. I built Jargonaut to bridge this gap: not to define words, but to translate understanding.
What it does~
Jargonaut is a universal interpretation platform that detects and translates specialized language across 20+ categories (Medical, Legal, Biblical, Medieval, Slang, Dialects, Tech, etc.) into plain English.
Key features include:
The Cognitive Dial: A slider that dynamically shifts reading complexity: Pro Lite: Keeps original text but adds definitions inline in parentheses. Layman: Standard everyday English. ELI5 (Explain Like I'm 5): Extremely simple words using customized metaphors (LEGO bricks, Cooking, or Sports).
Jargon Density Heatmap: Visualizes clusters of difficult terms in glowing shades of red.
Fuzzy search Lexicon: A searchable glossary featuring Levenshtein-driven "Did You Mean?" suggestion chips for typos.
Utility Tools: Native speech-to-text dictation, drag-and-drop document parsing (.txt/.md/.json), and one-click Side-by-Side Clarity PDF Report exporting.
Study Arena: A gamified study station with 3D card-flip animations and multiple-choice questions to review terms and build streaks.
How I built it~
I built Jargonaut using a layer-by-layer architectural workflow:
The Web Prototype: I designed a premium, serverless glassmorphism frontend using HTML5, Vanilla CSS, and JavaScript.
The AI Engine: I directly integrated the Gemini 2.5 Flash API using structured JSON schemas to ensure reliable API responses.
The Fuzzy Finder: I coded a native Levenshtein Distance matrix calculation for search queries. For a user input string (a) of length (i) and term (b) of length (j), the edit distance is computed as:
[ \text{lev}{a,b}(i,j) = \min(\text{lev}{a,b}(i-1,j) + 1, \,\, \text{lev}{a,b}(i,j-1) + 1, \,\, \text{lev}{a,b}(i-1,j-1) + \mathbb{I}(a_i \neq b_j)) ]
with boundary conditions:
- (\text{lev}_{a,b}(i,0) = i)
- (\text{lev}_{a,b}(0,j) = j)
The Native Android Companion: I bootstrapped and compiled a native app using Kotlin and Jetpack Compose. It mirrors the web app's features (Decipher, Lexicon, 3D Quiz, and Settings) and caches custom vocabulary locally.
I also designed a mathematical metric for Clarity (C) based on the density of detected jargon words (J) with category weight (w_i) over total words (N):
[ C = \max\left(15, \,\, 100 - \sum_{i=1}^{k} \left( w_i \cdot \frac{J_i}{N} \cdot 100 \right)\right) ]
Challenges I ran into~
Contextual Slang Inversion: Slang words often use standard vocabulary with inverted meanings (e.g., gamer 'aggro' or surfing 'shred'). Standard dictionary lookups failed. I solved this by using detailed system prompt engineering instructing Gemini to prioritize figurative, context-dependent usage.
JSON Schema Reliability: Dynamic highlights require the UI to know exactly where terms start and end. Free-form AI responses caused frequent layout breakage. I resolved this by forcing Gemini to output strict, structured JSON arrays that map directly to my frontend components.
Android Dependency Conflicts: Integrating heavy third-party JSON serialization libraries caused build failures in Gradle. I bypassed this by utilizing Android's built-in, native org.json.JSONObject class, resulting in a lightweight, robust build with zero external classpath dependencies.
Accomplishments that I am proud of~
Beautiful Aesthetics: Creating a premium, glassmorphic UI with smooth animations, custom progress gauges, and intuitive user controls on both web and Android.
The Metaphor Analogizer: Having the system dynamically generate analogies matching LEGOs, cooking, or sports, which makes abstract concepts immediately understandable.
The 3D Card Flipping Animation: Writing a custom Jetpack Compose graphics pipeline that smoothly rotates quiz flashcards along the Y-axis.
What I learned~
The Power of Structured Output: Constraining model outputs using JSON schemas completely eliminates the need for complex, post-process regex parsing.
Modular Architecture: Keeping my glossary database completely decoupled from the UI enabled me to reuse the exact same core lexicon logic across both JavaScript and Kotlin.
What's next for Jargonaut~
On-Device AI Integration: Run localized, offline translations using Gemini Nano directly on the mobile device.
Visual Deciphering (OCR): Allow users to snap a photo of a document (like a physical menu or a printed patient summary) and overlay translations directly on the image.
Vocabulary Sharing: Create team workspaces where colleagues can share a custom lexicon database.
Built With android artificial css gemini git google gradle html5 intelligence javascript latex markdown vertex
Log in or sign up for Devpost to join the conversation.