Files store code.
Kin knows it.
Files are transient, flattened reflections of code relationships. Kin indexes the underlying logic directly and keeps a standing semantic graph on your machine. The graph holds authority, and flat files stay as compatible projections.
kin-vfs: Transparent libc Interception
Existing developer tools (compilers, linters, and editors) know nothing about code databases. They require a raw filesystem. Instead of writing heavy FUSE mount drivers, kin-vfs achieves transparent filesystem projection via dynamic library interposition.
By injecting a lightweight shim (LD_PRELOAD on Linux / DYLD_INSERT_LIBRARIES on macOS), Kin intercepts low-level standard library calls like open(), openat(), and read().
No raw file search in the answer path
Agents and linters are blocked from scanning flat code buffers directly. Code reads are dynamically resolved from structural AST nodes and slices inside the graph on demand.
Transparent Daemon Routing
The shim intercepts the file read path, query-routes it to the local running kin-daemon via a fast Unix Domain Socket, and materializes semantic views.
Transparent Local Disk Fallback
Any path outside Kin's database boundaries (like node_modules or compiler configuration files) bypasses interception and falls back directly to the local disk.
How interception works
Interception System Standing
Click on any node in the interactive diagram above to explore its technical role in the transparent virtual filesystem pipeline.
{
"entity_id": "7b4c6e93-18aa-462a-bd1e-5a02568603be",
"token_budget": 16000,
"depth": 2,
"include_traffic": true,
"compact": false
}> FOCAL_ENTITY: auth.validate_auth_token [Rust]
Signature: fn validate_auth_token(token: &str) -> Result<Claims, AuthError>
Line Range: 142 - 188 in src/auth/validate.rs
> DEPENDENCIES (SignatureOnly):
- auth.decode_jwt (calls) - [ID: bd11d-283]
- models.Claims (imports) - [ID: ac23a-442]
> CO-WORKING TRAFFIC ALERT:
Warning: Session `b4c1f9e2-7a3d-4e8f-9c26-d05a718e42b1` holds a registered intent to modify entity `auth.decode_jwt`. The intent is released when that session ends, or at the expiry the agent set. Coordinate before writing to avoid a merge collision.
kin-mcp: Model Context Protocol Server
Coding assistants burn prompt tokens rebuilding structure from raw directories. Kin exposes its standing, pre-indexed semantic graph directly over the Model Context Protocol.
Wired through the MCP server, agents such as Claude Code, Cursor, Windsurf, and Codex get entity-first reasoning APIs rather than raw file reads.
get_context_pack()
Gathers a focal entity, its implementation, and callers up to depth=N. Draws context boundaries that isolate dependencies and prevent prompt leakage.
find_references()
Returns the entities that reference a target, resolved from recorded graph edges rather than text matches, so agents see what depends on a symbol before changing it.
Language Adapters
Kin parses codebase structures at the Abstract Syntax Tree (AST) level, recognizing declarations, imports, overloads, and call boundaries instead of raw characters.
Full imports, classes, functions, variable scopes & type enrichment.
Dynamic AST, ES modules & CommonJS require, classes, scopes.
Module imports, class definitions, function boundaries, decorators.
Package scopes, struct & interface implementations, direct call graphs.
Class/interface hierarchies, method overrides, package bindings.
Struct/trait impls, macro expansions, mod declarations, full modules.
Function declarations, header inclusion hierarchies, macro expansion.
Namespaces, class methods, template scopes, operator overloading.
Namespace groupings, class outlines, properties, method signatures.
Class/module namespaces, method boundaries, require scopes.
Classes, functions, namespaces, traits, dynamic function inclusions.
Protocol extensions, structures, generic bounds, closure mappings.
Kotlin packages, data classes, extension methods, inline scopes.
Infrastructure blocks, module bindings, variables & resources.
No language adapter matches
Try searching for other file extensions or core terms.
Your first graph is one command away.
Install Kin, parse your repository, and launch the local daemon in a few minutes. Your AI assistant gets semantic context over your codebase.