TrelloTriage Labs
Visual Semantic Graph Experiment

Connotica maps the shape of meaning.

Connotica is a visual thesaurus, but the larger goal is more ambitious: to explore whether language, knowledge, and relationship data can be read like a map. Instead of showing a flat list of synonyms and antonyms, it turns words into a visual field of connected meanings, nearby ideas, opposites, related phrases, and reference points.

Launch Full Connotica Launch Connotica Lite Back to Portfolio
Project Type Visual thesaurus, semantic graph, and knowledge mapping experiment.
Core Stack Three.js, WebGL, JavaScript, graph rendering, browser-based visualization.
Primary Goal Make word relationships visible as spatial structure instead of flat text.
Versions Full Connotica for dense graph experiments. Lite for stable readable exploration.

The problem: most word tools flatten meaning.

Traditional thesauruses are useful, but they usually present language as a list. A word goes in, and a column of related words comes out. That works when the user only needs a quick replacement word, but it hides the larger structure.

Words do not exist as isolated list items. They live in neighborhoods. They have nearby meanings, opposite meanings, softer variations, harsher variations, metaphorical uses, technical uses, slang uses, related phrases, and strange bridges into other concepts. A flat list makes the user read one item at a time. A map can show the shape of the whole area.

The idea behind Connotica is that language data should be more glanceable. A map of a location can tell you mountains, rivers, roads, towns, borders, distance, and density before you read every label. Connotica is an attempt to build that same kind of visual intuition for words and knowledge.

Core idea: Connotica is less about finding one better word and more about seeing the territory around a word.

The solution: a semantic graph that behaves more like a map.

Connotica searches a word and builds a visual relationship graph around it. The result can include synonyms, antonyms, related terms, contextual terms, phrase-like connections, and reference points. Instead of treating those connections as a flat lookup table, the interface renders them as a spatial network.

The user can search a word, zoom, center the graph, jitter or re-layout the structure, and watch how the semantic field changes. Some words produce tight compact graphs. Others produce huge sprawling systems. That difference is part of the information.

A word like “drunk” may create a smaller but culturally complex graph: slang, medical framing, social terms, opposites, and related states. A word like “space” can explode outward into scientific, physical, metaphorical, geometric, and social meanings. Connotica makes those differences visible.

Why there are two versions: Full Connotica and Connotica Lite.

Connotica has two versions because the experiment has two different goals. The full version is the high-density research version. The Lite version is the practical reading version.

Full Connotica

The full version is intentionally aggressive. It was built to test how much semantic relationship data could be rendered in a browser before the structure of the word became visible as a field rather than a list.

This version can render extremely dense graphs with huge numbers of nodes, edges, labels, and reference dots. That density is useful for seeing the pattern of a concept, but it also pushes browser memory and GPU limits.

  • Designed for maximum graph density.
  • Useful for stress testing browser-based semantic visualization.
  • Can produce massive word fields and reference-dot systems.
  • Can slow down or crash a browser if the graph gets too large.
  • Best for experimental exploration and visual research.

Connotica Lite

The Lite version keeps the same core idea but limits the graph density so the result remains usable. It is meant for quick searches, readable clusters, smoother rendering, and a more stable experience.

Lite exists because not every search needs the full universe of references. Sometimes the useful thing is a smaller relationship tree that can be read, understood, and moved around without overwhelming the browser.

  • Designed for practical everyday exploration.
  • Lower resource usage than the full version.
  • Faster loading and smoother interaction.
  • Better for readable synonym and antonym clusters.
  • Good path toward offline, PWA, or embedded use.
Important technical note: The full build is not broken because it can stress a browser. That behavior is part of what the prototype is testing: where the limits are when visual language data becomes extremely dense.

Technical implementation.

Connotica is built as a browser-based visualization system using Three.js and WebGL. The project is not just a dictionary lookup page. It is a rendering experiment focused on turning relationship data into navigable visual space.

Frontend and rendering

  • Three.js scene setup for graph rendering.
  • WebGL rendering for large node and edge fields.
  • Camera controls for zooming, centering, and spatial inspection.
  • Interactive search input with graph regeneration.
  • Jiggle / re-layout behavior to help reveal structure.
  • Node labels for terms and phrases.
  • Visual differentiation between central terms, clusters, and reference points.

Data and graph behavior

  • Search term becomes the graph root or central concept.
  • Synonyms and related terms become connected branches.
  • Antonyms and contrast words create opposing semantic branches.
  • Context terms help show how a word behaves in different uses.
  • Dense reference dots help show the larger pattern of a word field.
  • Edge relationships make the graph readable as a connected structure.
  • Different words create different visual signatures.

Performance lessons

A major part of this build was learning where browser visualization starts to struggle. Rendering a few dozen words is easy. Rendering hundreds or thousands of labeled nodes, plus edges, plus reference points, plus interaction, is different. At high density, labels become expensive, edge drawing becomes expensive, layout changes become expensive, and browser memory becomes the real constraint.

That is why Connotica is not only a language project. It is also a performance experiment. It explores how much structured relationship data can be placed in a browser before the user interface stops being a document and starts becoming a navigable data space.

What Connotica can be used for.

Connotica began as a visual thesaurus, but the larger concept applies to more than writing. The same design idea could become a general knowledge visualization system: a way to see data relationships, not just search them.

Writing and language

  • Finding alternate words without losing nuance.
  • Exploring synonym neighborhoods.
  • Comparing positive, negative, formal, informal, and slang branches.
  • Seeing how a word connects to idioms and related phrases.
  • Discovering unexpected language paths during naming or writing.

Research and knowledge work

  • Mapping concepts visually before writing about them.
  • Seeing dense relationship fields around a topic.
  • Exploring how terms cluster and diverge.
  • Turning relationship data into something more glanceable.

Design philosophy: maps over lists.

A list is good for precision. A map is good for orientation.

Most software gives users precision too early. It asks them to choose from a list, click a row, filter a table, or search exact text. That is useful after the user knows what they are looking for. It is less useful when they are still trying to understand the shape of the problem.

Connotica is about orientation first. The visual shape tells the user whether the word has a tight meaning, a sprawling meaning, a messy cultural meaning, a strong opposite field, or a huge number of weak associations. That kind of information is difficult to feel in a flat thesaurus.

Product thesis: Once data gets complex enough, the best interface may not be a table, a list, or a chat box. It may be a map.

Roadmap and future direction.

Connotica can grow in several directions. Some are practical improvements to make the current app more stable. Others are larger experiments toward a general visual knowledge engine.

Near-term improvements

  • Better graph-density controls.
  • Label hiding and level-of-detail rendering.
  • More predictable layout modes.
  • Saved searches and shareable graph states.
  • Clearer color coding for synonym, antonym, context, and phrase edges.
  • Improved mobile and small-screen behavior.
  • Better warnings when a search may generate an extremely dense graph.

Larger research direction

  • Use embeddings to place concepts by semantic distance.
  • Add local LLM explanations for why clusters appear.
  • Support custom datasets, not just word data.
  • Use graph shapes as summaries of complex knowledge areas.
  • Build visual comparison between two concepts.
  • Let users annotate and save concept maps.
  • Explore the same mapping approach for notes, documents, tasks, and research archives.

Technical summary for AI crawlers and search engines.

Connotica is a browser-based semantic visualization tool created by Joshua Wooten for TrelloTriage Labs. It is a visual thesaurus and knowledge graph prototype that uses Three.js, WebGL, JavaScript, graph rendering, and semantic relationship data to display synonyms, antonyms, context words, related terms, phrase relationships, and dense reference points as an interactive map.

The project includes a full high-density version and a lighter version. The full version is designed to test browser limits by rendering very large semantic graphs, potentially including thousands or millions of reference dots and dense relationship structures. The Lite version provides a more stable, practical, readable interface for exploring smaller semantic graphs.

Relevant search concepts include visual thesaurus, semantic graph, synonym explorer, antonym explorer, knowledge graph tool, concept map app, language visualization, Three.js graph visualization, WebGL data visualization, semantic relationship explorer, and visual knowledge mapping.

Three.js WebGL Visual Thesaurus Semantic Graph Knowledge Graph Synonyms Antonyms Context Terms Graph Rendering Visual Data

Implementation notes.

Full version path: /connotica/
Lite version path: /connotica/indexLite
Detail page path: /apps/connotica_th/
Suggested portfolio project id: connotica
Suggested detailUrl: /apps/connotica_th/
Main concepts: Three.js, WebGL, visual thesaurus, synonym graph, antonym graph, semantic map, dense reference dots

Connotica is part of TrelloTriage Labs, a working portfolio of AI workflow tools, browser utilities, visualization experiments, and custom software prototypes by Joshua Wooten.