CodeAtlas: a visual map of your development machine

A real model of what's actually running on this machine.

CodeAtlas scans your projects, processes, ports, Docker resources, runtimes, and package managers, and builds the dependency graph between them from real evidence: a container really was instantiated from that image, a process really is listening on that port. It runs entirely on your machine, with no account, no cloud sync, no upload, and no telemetry by default.

Clone from GitHub See the dependency graph

Sample data, not a scan of your machine

This is the same rendering code the desktop app uses (force layout, kind-family colors, hover-to-highlight), running on eight fabricated resources instead of a real scan. The full version is in section 04.

The machine map

Every screen in CodeAtlas is a view onto one typed model. A resource is one of 21 kinds, grouped here into the eight families the app's own dependency-graph legend uses. This is the actual type list from the app's source, not a paraphrase of it.

Source: `src/lib/types.ts`, `ResourceKind`. Colors: `src/lib/kind-colors.ts`, unmodified.
Kind	What it is
ORIGIN
project	A discovered codebase: `package.json`, `Cargo.toml`, `go.mod`, or a similar manifest marks the root.
VERSION CONTROL
git_repository	`.git` metadata: branch, status, recent commits, redacted remote URL.
RUNTIME & PROCESS
process	A running process, read from the OS process table.
runtime	An installed language runtime, detected on `PATH` (Node, Python, Go, Rust, Ruby, Java, .NET).
network_listener	A process's listening socket, cross-referenced against the port it's bound to.
port	A TCP/UDP port with something listening on it.
CONTAINERS
docker_container	A container, running or stopped.
docker_image	An image, whether or not any container currently uses it.
docker_volume	A named volume, whether or not any container currently mounts it.
docker_network	A user-defined Docker network.
PACKAGE MANAGEMENT
package_manager	An installed package manager (npm, pnpm, yarn, bun, pip, cargo, Homebrew, apt/dpkg, winget/choco).
package	A dependency declared by a project's manifest or lockfile.
ENVIRONMENT & TOOLING
tool	A developer tool detected on `PATH`.
environment_variable	A variable name observed in a process's environment. Values are never read.
ssh_config_entry	A `Host` alias from `~/.ssh/config`: hostname, user, and port only, never key material.
config_file	A recognized config filename inside a project root.
EPHEMERAL / STORAGE
build_artifact	Compiled output from a build step (`target/`, `dist/`, `build/`).
cache	A known package-manager or tool cache directory.
disk_usage_entry	A sized, dated directory the disk-usage provider flagged as worth knowing about.
SERVICE INFRASTRUCTURE
service	An OS-level background service (launchd on macOS, systemd user units on Linux).
database	A logical database observed via container or service metadata.

One project's full record

Click a project, or tab to it and use the arrow keys, to see its detail pane: the same one the app opens on hover-then-click, never a modal, never a separate route. Three fabricated projects, so the pane has something real to show.

Sample data

api-gateway TypeScript · Express billing-service Rust · axum worker-queue Python · celery

api-gateway

project

~/Developer/api-gateway

language: TypeScript
framework: Express
branch: main
first_seen: 2026-03-02
last_seen: 2026-08-21 09:14

Evidence

projects
package.json found at project root
~/Developer/api-gateway/package.json
git
.git directory found, 3 local branches
~/Developer/api-gateway/.git

billing-service

project

~/Developer/billing-service

language: Rust
framework: axum
branch: main
first_seen: 2026-01-18
last_seen: 2026-08-21 09:14

Evidence

projects
Cargo.toml found at project root
~/Developer/billing-service/Cargo.toml
git
.git directory found, 1 local branch
~/Developer/billing-service/.git

worker-queue

project

~/Developer/worker-queue

language: Python
framework: celery
branch: main
first_seen: 2026-05-27
last_seen: 2026-08-21 09:14

Evidence

projects
pyproject.toml found at project root
~/Developer/worker-queue/pyproject.toml
git
.git directory found, 2 local branches
~/Developer/worker-queue/.git

The graph is the content

Real force layout (link + charge, settles under ~800ms then stops: no idle drift), real kind-family colors, real hover/selection rules: direct edges brighten to copper, everything else dims to 8%. Scroll to zoom, drag to pan, click a node or use the arrow keys once it's focused.

38 fabricated resources, 34 fabricated relationships: not a scan

scroll to zoom · drag to pan
arrow keys to cycle nodes

Keyboard-accessible list view (same sample data)

Resource	Kind	Relationship	To
api-gateway	project	uses	Node 20.11.1
api-gateway	project	depends_on	express 4.19.2
billing-service	project	connects_to	database: billing
billing-service	project	uses	Rust 1.78.0
postgres-dev	docker_container	instantiated_from	postgres:16
postgres-dev	docker_container	mounts	pgdata volume
worker-queue	project	connects_to	redis-cache container

Recommends. Never deletes.

The cleanup center surfaces unused Docker images and volumes, stale build artifacts, and caches, each with its size, evidence, last-used time, what depends on it, and exactly what removing it would do. CodeAtlas does not delete anything in the current release; you decide.

Sample data: expand a row for the reasoning

pnpm store~/Library/pnpm/store 2.1 GB 37d ago 0 deps

Package-manager cache, not read by any running process in this scan.

The next install re-downloads packages from the registry.
target/~/Developer/billing-service/target 1.4 GB 50d ago 1 dep

Debug build output, older than the project's most recent commit.

The next cargo build regenerates it. The running billing-service process would need a rebuild first.
node:18-alpinedocker image 187 MB 228d ago 0 deps

No container on this machine is instantiated from this image.

Removing it frees the image layer. Re-pulling it later costs one download.
old_pgdata_backupdocker volume 640 MB 223d ago 0 deps

Not mounted by any container in this scan.

Docker volumes are deleted with their data. Confirm nothing still reads this backup before removing it: this one is flagged not reversible.
node_modules/~/Developer/api-gateway/node_modules 850 MB 11d ago 1 dep

31,402 files: larger than most dependency trees seen across this sample scan's projects.

The next pnpm install regenerates it from the lockfile. The running api-gateway process would need a restart first.

LOCAL.

What CodeAtlas reads, and what it never does

CodeAtlas reads sensitive material by design: process lists, environment variable names, SSH host configuration, Docker metadata, project source trees. Here is exactly what that means, restated from PRIVACY.md and SECURITY.md, the project's own docs.

NO UPLOAD

There is no server component. The discovery and storage code has no network client in it at all.

NO TELEMETRY BY DEFAULT

No usage analytics, no crash reporting to a remote service, no update-check that reports back identifying information. An opt-in feature would default off and this page would be updated first.

NO ACCOUNT

No sign-up, no login, no cloud sync in the current release.

ENV VARS: NAMES ONLY

Variable values are never read into a resource, never persisted to the database, and never sent to the frontend.

SSH CONFIG: FOUR FIELDS

Only Host, HostName, User, and Port from ~/.ssh/config. Private keys and known_hosts are never opened.

GIT REMOTES: CREDENTIALS STRIPPED

Any userinfo token embedded in a remote URL (https://TOKEN@host/...) is stripped before the URL is ever stored or displayed.

COMMAND LINES: TRUNCATED AND CHECKED

A short preview only, executable name plus one argument. A real scan during development surfaced a credential passed as a command-line argument by an unrelated tool, so every surviving token is now additionally checked against a secret-shaped pattern before storage.

WHERE IT LIVES

A single SQLite database in your OS's standard application-data directory. Nothing leaves that file unless you export or share it yourself.

Where this has actually run

Platform	Status	Detail
macOS	Verified	Run and verified against real, live system data. The primary development platform so far.
Linux	Compiles, untested on hardware	Platform code compiles and passes unit tests for its parsing logic; has not yet been run end-to-end against a real Linux machine.
Windows	Compiles, untested on hardware	Platform code compiles and passes unit tests for its parsing logic; has not yet been run end-to-end against a real Windows machine.

CI builds an installer for macOS (arm64 + x64), Linux, and Windows on every tagged release, independent of the verification status above.

The disk-usage provider walks and sizes cache/build-artifact directories synchronously; on the author's own ~/Developer with 79 projects, it's the slowest single provider, observed around 15 to 20 seconds. It doesn't block the others, since they run concurrently, but it sets the floor for total scan time.

Also a CLI

CodeAtlas ships a scriptable CLI, codeatlas, built from the same discovery engine the desktop app uses.

Command syntax is real. Output below is sample data.

$ codeatlas scan
Scanning configured search roots...
  projects              4 found      0.04s
  git                    3 found      0.11s
  processes              5 found      0.02s
  docker                10 found      0.41s
  runtimes               3 found      0.09s
  package_managers       5 found      0.06s
  tools                  1 found      0.01s
  environment             2 found      0.01s
  ssh                     1 found      0.01s
  disk_usage              3 found      2.31s
  services                1 found      0.03s

scan complete: 38 resources, 34 relationships, 11 providers, 4.9s

$ codeatlas ls project
api-gateway         ~/Developer/api-gateway         TypeScript · Express
billing-service      ~/Developer/billing-service      Rust · axum
worker-queue          ~/Developer/worker-queue          Python · celery

$ codeatlas search postgres
docker_container    postgres-dev            image postgres:16, port 5432
docker_image        postgres:16             438 MB
database            billing                 engine postgres 16
service             postgresql@16           launchd, port 5432
port                :5432                   bound by 2 resources: see cleanup notes

$ codeatlas changes
2026-08-19  discovered   environment_variable   STRIPE_API_KEY
2026-08-10  modified     docker_image           node:18-alpine (now unused)
2026-07-02  modified     build_artifact         target/ (0.9 GB -> 1.4 GB)
2026-06-30  modified     docker_container       redis-cache (running -> exited)
2026-05-27  discovered   project                worker-queue

$ codeatlas scans
2026-08-21 09:14   completed   38 resources   11 providers   4.9s
2026-08-20 22:03   completed   37 resources   11 providers   5.1s

The real app

Five views of the actual running application: not mockups.

Screenshot of the CodeAtlas desktop app's Overview view — Overview: the machine's top-level summary.

Screenshot of the CodeAtlas desktop app's Projects view, list and detail pane — Projects: the dense list and resizable detail pane.

Screenshot of the CodeAtlas desktop app's Dependency Graph view — Dependency graph: the real canvas render on a real machine's data.

Screenshot of the CodeAtlas desktop app's Cleanup Center view — Cleanup center: candidates with evidence, size, and consequence.

Screenshot of the CodeAtlas desktop app's Timeline view — Timeline: the diffed change history between scans.

Dual-licensed, publicly developed

Dual-licensed under MIT or Apache License 2.0, at your option. Apache-2.0 adds an explicit patent grant, which matters for software that inspects a machine's installed toolchains and containers; MIT satisfies anyone who prefers the simpler, more permissive option. This is the convention most of the Rust ecosystem uses, which keeps CodeAtlas's own dependency tree license-compatible without friction.

CI: Rust + frontend lint/test/build CodeQL: JS/TS, on push + weekly cargo audit in CI Dependabot: cargo, npm, GitHub Actions

MIT

The simpler, more permissive option. LICENSE-MIT

Apache License 2.0

Adds an explicit patent grant. LICENSE-APACHE

github.com/levimackay/codeatlas · Contributing guide · Architecture

Run it on your own machine

No tagged release is confirmed at the time this page was built. Until installers are published on the Releases page, build from source:

git clone https://github.com/levimackay/codeatlas.git && cd codeatlas && pnpm install && pnpm tauri dev

Clone from GitHub Check Releases

Once installers exist, expect them to be unsigned at first: no Apple Developer ID or Windows code-signing certificate is configured yet, so macOS will show an "unidentified developer" Gatekeeper warning and Windows will show a SmartScreen warning on first launch.