All releases
Version 0.1.101BetaFirst public release

Graphtia Explorer — First public release

Explore a local structural index of your code, project documents, declared APIs and database contracts. Follow source-backed relationships in Explorer or query them from a connected coding client.

Added

  • Local graph navigation, symbol search, dependencies, impact candidates, related tests and findings across supported language and framework surfaces.
  • Declared HTTP/gRPC APIs, OpenAPI 3.0/3.1 contracts and PostgreSQL, SQLite and MySQL schema evidence, with explicit static-analysis limits.
  • Managed coding-client integrations and a local universal MCP connection with separate workspace approval.
  • Free access includes two registered workspaces per local installation and 100,000 code LOC per workspace.

Improved

  • Install now shows preparation feedback while authorization is pending, prevents duplicate requests and restores controls after an error without announcing success early.

Fixed

  • Fixed an account-check deadlock that could block update preparation before installation.

Known limitations

  • Analysis is static. Dynamic behavior, unsupported constructs, incomplete compilation context and ambiguous bindings can remain unresolved.
  • Product Audit is unavailable. The MCP audit_structure operation remains a separate read-only structural query.
  • Downloads target Windows x64 and Linux x64/Ubuntu DEB. This release does not include macOS or ARM packages.
  • Local processing still requires valid account and signed product access; an offline connection does not extend expired authorization.

Source languages and project structure

The official support inventory defines 10 language-ecosystem descriptors, one project-model descriptor, 23 framework-category adapters and four boundary adapters. These are distinct categories: TypeScript and JavaScript share an ecosystem; C/C++ and prepared Arduino share another; HTML and CSS provide markup/stylesheet analysis; project manifests are not an additional programming language. The counts do not imply uniform semantic depth.

Source languages and project structure
EcosystemAvailable static analysis and principal limits
TypeScript / JavaScript, including TSX / JSXDeclarations, scopes, module/package resolution, aliases, imports, CommonJS, references and supported calls. Full TypeScript type checking, declaration merging and arbitrary dynamic dispatch are outside the current scope.
Rust / CargoModules, functions, types, traits, type uses, project structure and supported calls. Recognized macro arguments retain evidence; macros are not expanded and the analyzer does not replace rustc.
GoPackages, modules/workspaces, functions, methods, types, embedding, interfaces/method sets and tests. Runtime interface selection, cgo, build tags and some generic behavior remain partial.
JavaDeclarations, overload-aware calls, inheritance, annotations, JPMS and static Maven/Gradle metadata. Reflection, annotation processors, runtime DI and executable build logic are not resolved universally.
C# / .NETAn official separate-process Roslyn analyzer supplies declarations, overloads, generics, attributes, partial/extension methods and static project metadata. The matching packaged analyzer/runtime is required; generators, reflection, dynamic dispatch and MSBuild are not executed.
C / C++ / prepared ArduinoPartial libclang-based declarations, references, calls and types using an official process adapter and explicit compilation/header snapshots. Compilation commands are never executed. Arduino requires prepared generated C++, board/core inputs and exact sketch source maps; ordinary sketches or arbitrary boards are not automatically complete.
PythonModules/packages, conservative imports/calls, types, decorators, async/generators, tests and static packaging metadata. Projects, setup scripts and build backends are not imported or executed; dynamic features remain partial.
PHP / ComposerNamespaces, classes, traits, members, static includes and supported embedded web-language structure. Dynamic autoloading, reflection and framework magic retain limits.
HTMLElements, forms, assets, IDs/classes and supported embedded JavaScript/CSS regions. This is structural markup evidence, not observed browser DOM behavior.
CSSSelectors, custom properties, imports, keyframes, URLs and static references. This does not calculate applied styles or the full runtime cascade.

Project and package metadata contribute workspace ownership, entrypoints and configuration context. Supported embedded-language regions map evidence back to the original source. Recognizing a file extension, displaying syntax highlighting or reading JSON/TOML configuration does not establish semantic-language support.

Framework and cross-language evidence

The 23 framework-category adapters cover these static surfaces:

  • Web: React/Next.js, WordPress and Laravel.
  • Go: net/http, Gin, Echo, Fiber and gRPC Go.
  • Java: Spring/Spring Boot, JAX-RS/Jakarta REST, JPA/Hibernate and gRPC Java.
  • .NET: ASP.NET Core, built-in DI, EF Core and gRPC .NET.
  • Python: FastAPI, Django, Flask, SQLAlchemy and Celery.
  • Database-code evidence: one TypeScript/JavaScript adapter and one Python adapter. These two are included in the 23; they are not additional web frameworks or database engines.

Four generic boundary families connect supported Tauri IPC, HTTP, generated-style Go/Java/.NET gRPC, and Python/Celery task producers and providers. Cross-language links preserve boundary relationships instead of inventing ordinary function calls. Supported evidence can be followed from a client to an API provider, its code owners and declared database tables when each leg is resolvable. Dynamic routes, unknown receivers, ambiguous applications and unsupported legs remain explicit.

APIs, OpenAPI and databases

  • Browse supported static HTTP/gRPC provider and consumer candidates with protocol, role, owner, application scope and source evidence. Catalog totals are not an inventory of deployed endpoints.
  • Inspect OpenAPI 3.0/3.1 JSON or YAML: paths/methods, effective parameters, request/response declarations, local references and bounded nested schema graphs. Focused schema lookup can recover a selected declaration omitted from a broader view. Remote references and full JSON Schema/runtime payload validation are not performed.
  • Review method/path handler candidates and supported TypeScript/JavaScript JSON, status and Zod declarations. A separately qualified Next.js declaration association requires exact source/configuration evidence; a single candidate alone is not a verified runtime binding.
  • Inspect PostgreSQL, SQLite and MySQL declarations: tables, columns, types/nullability, keys, defaults, identity/sequence clauses, indexes and bounded ALTER/routine/trigger declarations. Dialect detection can require an explicit choice when evidence is ambiguous.
  • Retain supported CHECK forms, generated/index expressions, constraint options and cross-source CREATE/ALTER relationships. Ordered composition describes a conditional declared model, not applied migrations or deployed state.
  • Evaluate supported CHECK expressions against explicitly supplied typed samples and compare declarations with caller-imported DDL. Unknown expressions and SQL NULL semantics remain visible. No database is opened, no SQL is executed and no live schema is read or modified.
  • Follow supported Django/SQLAlchemy table evidence and TypeScript/JavaScript receiver/literal/prepared-query patterns for postgres, pg, better-sqlite3, mysql and mysql2. Owner identity, callback context, receiver provenance, unresolved candidates and SQL-site diagnostics remain attached. ORM structure in other adapters does not automatically imply the same code-to-table coverage.

Graphs, documents and evidence

Navigate files, symbols and source alongside calls, references, imports/dependencies, types, inheritance, embedded regions and supported boundary relationships. Inspect focused paths, local context, impact candidates, related tests, static findings and bounded system/module architecture projections.

Calls and imports are different questions: dependency/dependent queries follow imports/dependencies; caller/callee queries follow calls. Related-test evidence is classified by the supporting node/path strength. Inferred associations remain heuristic; none of these features runs tests, proves coverage percentages, certifies an endpoint deployment or predicts runtime breakage.

Supported TypeScript/JavaScript import identities and source patterns recognize Playwright, Vitest, Jest and Node's test runner. These are language-adapter capabilities, not four additional framework adapters. Arbitrary globals/reexports, generated titles and dynamic mocks retain their limits.

Code, documents and declared contracts have separate catalogs and counts. Project prose has its own reader and search. Document admission and search are bounded: eligible documents are at most 256 KiB and document search covers metadata plus a 4 KiB text prefix. Missing search results do not exclude later passages.

Published revisions, source ranges, analyzer identities, currentness, coverage and truncation are explicit. Retained history compares bounded file/exported-surface fingerprints; it is not Git history or a general semantic diff. Incomplete results never establish global absence.

Coding clients and MCP

The local MCP server exposes 26 canonical operations, including symbol search/resolution, calls, dependencies, references, paths, impact, tests, findings, local context, source evidence, architecture, project summary, document tools and API/SQL/contract tools. The bounded structural composite query is named audit_structure. An optional compact catalog groups the same operations into six visible tools.

Use JSON, compact DIGEST, or retained-data RECORDS/JSONL output as appropriate. Operation-specific continuation contracts preserve query arguments and revision/snapshot identity. Compaction and export remain separate from analysis limits: exporting more records cannot discover facts that were never analyzed. Focused recovery suggestions address the relevant node/edge or concept budget when returned; they do not guarantee a match or make every traversal resumable.

Managed integrations are provided for Codex, Claude Code/Desktop configuration routes, OpenCode, Antigravity, Visual Studio Code/Copilot, Devin Desktop/Windsurf aliases and MiniMax Code, alongside the documented universal-client route. These are external client integrations, not seven built-in AI agents, seven model providers or a promise of identical host features. Existing owned settings and optional local skills are reconciled under their ownership rules. Brief startup guidance and a conditional skill reminder help clients select tools and interpret evidence.

External clients retain their own model/provider configuration. Graphtia supplies local structural evidence; the client's subsequent use of a model provider is outside the local MCP server contract.

Agent activity and bounded saved history can lead back to workspace evidence. They do not expose or capture an entire model conversation. Server admission, queues, cancellation, deadlines and rate limits are bounded; clients must respect retry guidance rather than bypassing identity or permissions. An explicitly opted-in experimental local context/recovery cache can write or delete only its own session state. Repository/index queries remain observational; the unencrypted context cache is not a place for secrets.

Workspaces, indexing and resources

Workspace registration, approval of initial indexing, and agent read access are separate actions. A connected or self-declared client does not automatically gain access. Users can grant one-hour access or indefinite workspace read access until revocation, with identity/context restrictions retained across normal updates. These grants are distinct from account-session, product-policy and download-authorization lifetimes.

Choose incremental Update or a full Rebuild. Filesystem watchers, exact reconciliation and dependency-aware invalidation update the published index. On Windows and Linux, eligible no-change reuse depends on a verified source comparison and native delivery proof; missing, stale or unsafe proof falls back to normal work. A quiet queue alone is not proof. Bounded scheduling supports pause, resume and cancel, preserving the previous committed revision when cancellation precedes commit. Paused work is not claimed to survive application exit.

Workspace settings include source-discovery exclusions. Excluded or unsupported inputs remain outside the analyzed coverage; their omission is not evidence that the code has no relationships.

ERM (Elastic Resource Manager) coordinates scan resources. Eco, Balanced and Fast scan profiles set CPU-proportional ceilings. Dynamic resource admission reserves bounded work, responds to memory pressure and preserves technical storage/adapter limits. Scan resource controls are separate from product licensing and plan quotas: planning hints are not hard RSS caps, guaranteed CPU utilization or a claim that every repository fits any machine. Checksummed block storage, caches, transaction recovery and bounded history support local indexing without requiring the entire graph in memory.

Free access, local processing and delivery

Free provides up to two registered workspaces per local installation and 100,000 code LOC per workspace. It enables graph navigation, symbol search, dependencies, impact analysis, related tests, findings and agent integration. Quotas come from signed Cloud policy, not hardcoded commercial constants in the executable. Code LOC is distinct from document/contract counts; an over-limit indexing attempt preserves the previous committed index.

Code analysis and queries are local. Protected access still requires a valid account session and primary signed policy; losing connectivity alone does not erase valid access, but it cannot extend expired credentials or create perpetual offline authorization. Login/renewal, updates and optional support submissions depend on their services. Account restoration, plan/usage presentation and explicit support diagnostic preview remain separate from workspace permission.

Release downloads target Windows x64 and Linux x64/Ubuntu DEB. Check Downloads for the packages available with each release. Windows uses Authenticode; Linux update admission verifies the signed manifest/artifact and package identity before an explicit system-authorized transaction. The update flow and managed connection reconciliation preserve their existing permission boundaries. This entry does not imply macOS or ARM delivery. The source also provides local adapter contracts, SDK and reproducibility tooling; it does not promise a remote adapter marketplace or bundle every developer CLI with the desktop installer.

Analysis boundaries

Support is static and deliberately conservative. Dynamic behavior, unsupported language constructs, incomplete compilation context, unknown receivers and ambiguous bindings can remain unresolved. gRPC support does not imply standalone Proto or Python gRPC analysis; boundary adapters do not resolve arbitrary JNI/P/Invoke/cgo/FFI. Recognized but unsupported source extensions are not silently treated as complete evidence.

Product Audit is unavailable in this release. The separate MCP audit_structure query does not enable it. No universal speedup, latency, memory footprint, runtime correctness or executed test-coverage claim is made by this baseline.

Ready to explore this release?

View downloads

Graphtia

This page is on its way. Join the waitlist to hear what’s next for Graphtia.

Join waitlist