Skip to content
TheChatArchiveThe Chat Archive
Claudeclaude-opus-4-7-webdev· AnthropicHugging Face Arena WebDev Preferences (2026)

I want you to make a dictionary get the necessary data from this GitHub repo.…

  1. User

    I want you to make a dictionary get the necessary data from this GitHub repo. https://github.com/forzagreen/arabterm

  2. Claude Assistant

    I'll help you build a dictionary web app using data from the arabterm GitHub repo. Let me first explore the repository to understand its structure and data format.

    Great, this is a rich collection of Arabic/English/French scientific dictionaries. Let me look at the actual data structure in the repo.

    The main data is in arabterm.db (SQLite, 96 MB — too large) and categories.json. Let me look at the db/ folder which likely contains individual JSON files, plus categories.json.

    I have the categories JSON. The actual term data lives in the SQLite db (96MB — too big to download at runtime). Let me check if there's a public API or another way to query terms. Let me look at the CLAUDE.md for context.

    The website is deployed to GitHub Pages and generates JSON files per dictionary. Let me find those JSON downloads.

    Let me check the JSON download format for a specific dictionary.

    I have a great data source. Each dictionary has a page with a JSON download. Let me check for the JSON link on the page:

    I have exactly what I need. The pattern is https://forzagreen.github.io/arabterm/{name_tech}.json. Now let me plan the app:

    Plan:

    1. A modern React dictionary app that loads from forzagreen.github.io/arabterm/{slug}.json
    2. Sidebar of all dictionaries (from a hardcoded manifest based on the data I found)
    3. Load a dictionary on demand, show its terms in a searchable/paginated table
    4. Search across Arabic, English, French, with source-language filter
    5. RTL support for Arabic
    6. Beautiful, sleek design

    Let me check the existing App.tsx and set things up.

    Good. Now let me build the app. I'll create a dictionaries manifest, the main App with routing state, and components.

    Now let me create the icons component and the main components (Sidebar, Home, DictionaryView).

    Now the DictionaryView component - the term browser with search and pagination.

    Now the main App with layout, hash-based routing so URLs are shareable, and the mobile drawer.

    Let me check the index.css to make sure Tailwind is set up and Arabic fonts render well.

    Let me add typography that renders Arabic beautifully.

    Now let me build the project to check for errors.

    Build succeeded. Let me fix the CSS import order warning by moving the Google Fonts import to be first (before @import "tailwindcss").

    Build succeeded with no warnings. Here's what I built:

    ArabTerm Dictionary — Summary

    A sleek, multilingual dictionary web app that pulls data from the forzagreen/arabterm GitHub project.

    How data flows:

    • The repo publishes a static site at forzagreen.github.io/arabterm/ with one JSON file per dictionary (e.g. covid19.json, at_physics.json).
    • The app has a manifest of all 58 dictionaries (src/data/dictionaries.ts) with slugs, titles in AR/EN/FR, term counts, and topical groupings.
    • When you open a dictionary, the app fetches its JSON from that CDN on demand and caches it in memory.

    Features:

    • Home page — hero with total stats (58 dictionaries, 425k+ terms), quick-filter search, group filter chips (Medical, Engineering, Physical Sciences, Humanities, etc.), and a card grid.
    • Sidebar — searchable, grouped list of every dictionary with term counts; collapses into a mobile drawer.
    • Dictionary view — full metadata header, cross-language search (AR/EN/FR) with a language filter toggle, highlighted matches, 50-per-page pagination, and proper RTL rendering for Arabic terms.
    • Routing — hash-based (#/at_physics), so URLs are shareable and refresh-safe.
    • Typography — Inter for Latin, Noto Naskh Arabic for RTL text.

    Files built: index.html, src/data/dictionaries.ts, src/components/icons.tsx, src/components/Sidebar.tsx, src/components/Home.tsx, src/components/DictionaryView.tsx, src/App.tsx, src/index.css

  3. User

    her is a working example that uses that data and works better than the results you produced "https://wikitermbase.toolforge.org/"

  4. Claude Assistant

    Let me check out that working example to understand what makes it better.

    It's a SPA. Let me look at their GitHub repo and check their API.

    Let me check the wikitermbase repo to see how their API and search works.

    There's a real API. The key insight is that wikitermbase uses a cross-dictionary search — you type a word (Arabic, English, or French) and it searches ALL 425k terms at once, grouped by Arabic term. That's the fundamental UX advantage over what I built.

    Let me confirm the API works and check the response format.

    Excellent! The API is live, has CORS-friendly JSON, and returns beautifully grouped results with relevance scoring. Let me also check the frontend they built to understand their UX better.

    Perfect — the API is powerful and CORS-enabled. Now I have a clear plan. Let me completely rebuild the app around this API:

    New approach:

    1. Global search as the primary UX (like wikitermbase) — you type anything, it searches all 425k terms across 58 dictionaries.
    2. Results grouped by Arabic term with all occurrences across dictionaries, sorted by relevance.
    3. Show descriptions when available.
    4. Dark mode support (matches wikitermbase).
    5. Keep the dictionary browser as a secondary feature.
    6. Live search with debounce.
    7. Show which dictionary each result came from with a link.

    Let me rebuild.

    Now let me build the new App with dark mode, live search, and grouped results. I'll create small reusable components.

    Now the CSS with dark mode support. In Tailwind v4 the dark: variant follows a .dark class by default when configured; let me use the @custom-variant directive to ensure class-based dark mode works.

    Add the pre-paint dark-mode script to index.html to avoid FOUC:

    Now let me add a few more icons I need, then build the main components. Let me update icons.tsx to include theme icons.

    Now the main components. Let me create the ThemeToggle, SearchResults (grouped), and the redesigned App.

    Now the SearchResults component that renders the grouped API response:

    Now the main App — a single search-first page. I'll also keep dictionary browsing accessible.

    The Sidebar component is no longer used. Let me delete it and update the DictionaryView to support dark mode. Let me first check DictionaryView for classes that need dark: variants.

    Now update DictionaryView with dark mode classes. Let me rewrite it fresh since it needs quite a few adjustments.

    Now delete the unused Home and Sidebar components and Sidebar reference, then build.

    Build succeeded. Here's a summary of the rebuild inspired by wikitermbase:

    What changed

    The core UX flaw of my first version was that you had to pick a dictionary first, then search inside it — but you rarely know which of 58 dictionaries has your term. Wikitermbase solves this by treating the whole 425k-term corpus as one searchable index. I now do the same.

    Now using the live wikitermbase API

    • Endpoint: https://wikitermbase.toolforge.org/api/v1/search/aggregated?q=...
    • Powered by MariaDB's FULLTEXT MATCH … AGAINST full-text index — searches all 425k terms across all 58 dictionaries in one call, returns relevance-scored results grouped by Arabic term.
    • Also uses /api/v1/stats for live counts.

    Key improvements

    1. Search-first home page — big search input, live results as you type (300 ms debounce), press / to focus.
    2. Grouped results — matching terms are clustered by their Arabic normalisation, then each group expands to show every occurrence across dictionaries with the source dictionary name, page number, Wikidata ID, and a link to the original arabterm.org entry.
    3. Definitions — when a term has an Arabic description (many do), you can expand it in-line.
    4. Multi-hit highlighting — every occurrence of your query is highlighted in Arabic, English, and French simultaneously.
    5. Dark mode — three-way toggle (Light / Auto / Dark), persisted to localStorage, no flash on load thanks to a pre-paint script.
    6. Hash routing with query state — #/q=telescope is a shareable link that reopens the same search.
    7. Suggestion chips on empty state to guide first-time users (اشتقاق, telescope, calcul, etc.).
    8. Kept single-dictionary browsing as a secondary flow (#/browse and #/dict/<slug>) that still loads the per-dictionary JSON from forzagreen.github.io/arabterm.
    9. RTL typography with Noto Naskh Arabic — Arabic terms render correctly with proper line-height and font.

    Files built: src/data/api.ts, src/hooks/useDebounce.ts, src/hooks/useTheme.ts, src/index.css, index.html, src/components/icons.tsx, src/components/ThemeToggle.tsx, src/components/SearchResults.tsx, src/App.tsx, src/components/DictionaryView.tsx

Responses were produced in different, uncontrolled contexts (system prompts, settings, prior turns). This is not a benchmark.