Real open-source codebases, pinned to a commit

Code Analysis Demos (analyzed 2026-11-03)

10 open-source repositories in 10 languages, pinned to a recorded commit, plus a metrics-only analysis of the full PViz product.

Lobsters

Ruby

Rails link-aggregation site (the code behind lobste.rs)

175 Rails routes mapped to controller actions, and a 26-model cycle formed by ActiveRecord associations. The largest cycle is now reported without the reopened-Rails artifact that inflated it in October.

Source
lobsters/lobsters
ceb5e71f0d9f (2026-10-25)
default-branch HEAD on the October 2026 analysis date (same commit as the October demo)
Analyzer
PViz analyzer (the engine hosted analyses use)
revision 7d6597af01e2 · [email protected]
Analysis
Run 2026-11-03, status complete
14.3 s, 190 MB peak memory (limit 1,792 MB)
Languages and parsing
javascript (full), python (full), ruby (full)
14 warn, 494 ok
508
Files analyzed
25,850
Source lines
2 / 32
Cycle groups / largest (files)
1,475
Calls resolved in repo (40% of the calls that could reach repo code)

Call resolution (8,627 call sites)

Resolved in the repository
1,475
To libraries or the standard library
4,965
Ambiguous (several possible targets)
1,094
Unresolved (could be repo code)
1,093

The rate above is resolved ÷ (resolved + ambiguous + unresolved). Calls to libraries and the standard library cannot reach this repository, so they are shown separately and left out of it. Test code is included in these counts.

What the analysis shows

Checked in the sourceRoutes and controller hooks

The analyzer reads config/routes.rb and maps 175 routes to their controller actions (for example /404 to AboutController#four_oh_four; checked in the source). It also records 86 lifecycle hooks such as before_action filters, all with exact status.

FindingThe model cycle

The associations between models (has_many, belongs_to and similar) alone form a cycle of 26 models. In Rails this is expected: associations are declared on both sides.

Changed since OctoberA reopened-constant artifact is gone

The October demo reported a cycle of 42 files. config/initializers/console_methods.rb reopens module Rails only to nest console helpers, yet every Rails.application or Rails.cache call in the application was attributed to that file, and the file's own call to User closed a loop; lib/tasks/build.rake likewise attracted the specs' RSpec.describe calls. The current analyzer attributes a call on a constant to a repository file only when the repository defines methods for that constant, so these 150 spurious module dependencies are gone. The largest cycle now has 32 files: the same files the October page found once the artifact was set aside, which we checked in the source then.

FindingInheritance and calls

The analyzer records 98 inheritance links (for example, the moderation controllers inheriting from Mod::ModController). 8,627 call sites were analyzed and 17% resolve inside the repository.

Changed since OctoberUses of other files' constants are no longer counted as calls

In October, a method call on the value of another file's constant, such as User::NEW_USER_DAYS + 1 in a spec, was counted as a call into that file. It no longer is, because the method belongs to the value (here an integer), not to the file. The files still use those constants, so the 9 module dependencies that came only from such uses are now missing from the graph.

Largest cycle group

  • app/models/category.rb
  • app/models/comment.rb
  • app/models/domain.rb
  • app/models/flagged_commenters.rb
  • app/models/hat.rb
  • app/models/hat_request.rb
  • app/models/hidden_story.rb
  • app/models/inactive_user.rb
  • app/models/invitation.rb
  • app/models/link.rb
  • app/models/message.rb
  • app/models/mod_mail.rb
  • app/models/mod_mail_message.rb
  • app/models/mod_mail_recipient.rb
  • app/models/mod_mail_reference.rb
  • app/models/mod_note.rb
  • app/models/moderation.rb
  • app/models/notification.rb
  • app/models/origin.rb
  • app/models/read_ribbon.rb
  • app/models/saved_story.rb
  • app/models/story.rb
  • app/models/story_text.rb
  • app/models/suggested_tagging.rb
  • app/models/suggested_title.rb
  • app/models/tag.rb
  • app/models/tag_filter.rb
  • app/models/tagging.rb
  • app/models/user.rb
  • app/models/username.rb

30 of 32 shown

Most widely called symbols (calling files)

  • app/models/user.rb#User (42)
  • app/models/moderation.rb#Moderation (37)
  • app/models/story.rb#Story (36)
  • app/models/comment.rb#Comment (30)
  • app/models/tag.rb#Tag (25)
  • extras/routes.rb#Routes.title_path (19)

Endpoints (first rows of the inventory)

  • GET / -> app/controllers/about_controller.rb#AboutController#four_oh_four
  • GET {?}/ -> app/controllers/origins_controller.rb#OriginsController#for_domain
  • GET / -> app/controllers/search_controller.rb#SearchController#index
  • GET / -> app/controllers/search_controller.rb#SearchController#index
  • GET / -> app/controllers/story_urls_controller.rb#StoryUrlsController#all
  • GET / -> app/controllers/story_urls_controller.rb#StoryUrlsController#latest
  • GET {?}/ -> app/controllers/comments_controller.rb#CommentsController#redirect_from_short_id
  • GET {?}/reply -> app/controllers/comments_controller.rb#CommentsController#reply

8 of 175 shown

Compared with the October 2026 demo

The same commit, analyzed again with the current analyzer. Both columns use the same definitions; differences come from analyzer changes, explained in the findings above where they matter. The October demo recorded only the resolved-call count, so the other call-resolution rows show the current analyzer only.

MeasureOctober 2026 demoCurrent analyzer
Files analyzed
graph nodes (Go: packages)
508508
Source lines (SLOC)
non-blank, non-comment lines of analyzed files
25,85025,850
Module dependencies
distinct file-to-file links, test-only and name-match links excluded
966807
Relationship records
all edge rows of every kind, including links to external symbols
1,008849
Cycle groups
groups of files that depend on each other
22
Largest cycle (files)
size of the largest cycle group
4232
Most-imported module
distinct production importers of the top module
98 (console_methods.rb)59 (user.rb)
Call sites resolved in repo
calls resolved to a function inside the repository / all call sites
1,641 / 8,6271,475 / 8,627
Calls to libraries (external)
calls into other packages or the language's standard library
n/a4,965
Ambiguous calls
calls with several possible targets inside the repository
n/a1,094
Unresolved calls
calls that could reach repository code but were not pinned to a target
n/a1,093
Resolved of in-repo calls
resolved / (resolved + ambiguous + unresolved): external calls cannot reach the repository
n/a40%
Framework registrations
routes, handlers, hooks, entry points with resolution status
261261
Architectural zones
package-hierarchy zones
4242
Analysis time (s)
wall time of the analysis call
19.914.3
Peak memory (MB)
container memory peak during the analysis
341190

Limitations

  • Uses of value constants defined in other files (User::NEW_USER_DAYS) do not create a dependency on those files; the 9 such dependencies we found are missing from the module graph.
  • 58% of call sites go to Rails and gems, outside the repository.
  • Static analysis records relationships visible in the source. It does not see dynamic loading, reflection, or behaviour at runtime; verify important conclusions in the code.

Download the analysis

A full bundle of a large repository exceeds many models' context windows; the focused slices below answer one question each in a fraction of the size.

Focused slices

All slices, readable and compressed, with the commands used (65 KB)

Ready to run this on your own codebase?

Hosted analyses use the same analyzer as this demo, within your usage limits.

Analyze your repo