Sloc Cloc and Code (scc)

scc powers searchcode.com — structured code intelligence over any repo, built for AI agents.

A tool similar to cloc, sloccount and tokei. For counting the lines of code, blank lines, comment lines, and physical lines of source code in many programming languages.

Goal is to be the fastest code counter possible, but also perform COCOMO calculation like sloccount, LOCOMO estimation for LLM-based development costs, estimate code complexity similar to cyclomatic complexity calculators and produce unique lines of code or DRYness metrics. In short one tool to rule them all.

Also it has a very short name which is easy to type scc.

If you don't like sloc cloc and code feel free to use the name Succinct Code Counter.

Licensed under MIT licence.

Table of Contents

• Install
• Background
• Pitch
• Usage
• Configuration Files
• Complexity Estimates
• Unique Lines of Code (ULOC)
• COCOMO
• LOCOMO
• Git Insight Reports
• HTML Report
• Output Formats
• Performance
• Development
• MCP Server Mode
• Adding/Modifying Languages
• Issues
• Badges
• Language Support
• Citation

scc for Teams & Enterprise

While scc will always be a free and open tool for individual developers, companies and businesses, we are exploring an enhanced version designed for teams and businesses. scc Enterprise will build on the core scc engine to provide historical analysis, team-level dashboards, and policy enforcement to help engineering leaders track code health, manage technical debt, and forecast project costs.

We are currently gathering interest for a private beta. If you want to visualize your codebase's evolution, integrate quality gates into your CI/CD pipeline, and get a big-picture view across all your projects, sign up for the early access list here

Install

Go Install

You can install scc by using the standard go toolchain.

To install the latest stable version of scc:

go install github.com/boyter/scc/v3@latest

To install a development version:

go install github.com/boyter/scc/v3@master

Note that scc needs go version >= 1.25.

Snap

A snap install exists thanks to Ricardo.

$ sudo snap install scc

NB Snap installed applications cannot run outside of /home so you may encounter issues if you use snap and attempt to run outside this directory.

Homebrew

Or if you have Homebrew installed

$ brew install scc

Fedora

Fedora Linux users can use a COPR repository:

$ sudo dnf copr enable lihaohong/scc && sudo dnf install scc

MacPorts

On macOS, you can also install via MacPorts

$ sudo port install scc

Scoop

Or if you are using Scoop on Windows

$ scoop install scc

Chocolatey

Or if you are using Chocolatey on Windows

$ choco install scc

WinGet

Or if you are using WinGet on Windows

winget install --id benboyter.scc --source winget

FreeBSD

On FreeBSD, scc is available as a package

$ pkg install scc

Or, if you prefer to build from source, you can use the ports tree

$ cd /usr/ports/devel/scc && make install clean

Run in Docker

Go to the directory you want to run scc from.

Run the command below to run the latest release of scc on your current working directory:

docker run --rm -it -v "$PWD:/pwd:ro" --network none ghcr.io/boyter/scc:master scc /pwd

Manual

Binaries for Windows, GNU/Linux and macOS for both i386 and x8664 machines are available from the releases page.

• fastclocreplacementin_rust/>
• countlinesofcode_quickly/>

Pitch

Why use scc?

• It is very fast and gets faster the more CPU you throw at it
• Accurate
• Works very well across multiple platforms without slowdown (Windows, Linux, macOS)
• Large language support
• Can ignore duplicate files
• Has complexity estimations
• You need to tell the difference between Coq and Verilog in the same directory
• cloc yaml output support so potentially a drop in replacement for some users
• Can identify or ignore minified files
• Able to identify many #! files ADVANCED!
• Can ignore large files by lines or bytes
• Can calculate the ULOC or unique lines of code by file, language or project
• Supports multiple output formats for integration, CSV, SQL, JSON, HTML and more

• You don't like Go for some reason
• It cannot count D source with different nested multi-line comments correctly

Differences

There are some important differences between scc and other tools that are out there. Here are a few important ones for you to consider.

Blank lines inside comments are counted as comments. While the line is technically blank the decision was made that once in a comment everything there should be considered a comment until that comment is ended. As such the following,

/* blank lines follow
*/

Would be counted as 4 lines of comments. This is noticeable when comparing scc's output to other tools on large repositories.

scc is able to count verbatim strings correctly. For example in C# the following,

#
private const string BasePath = @"a:\";
// The below is returned to the user as a version
private const string Version = "1.0.0";

Because of the prefixed @ this string ends at the trailing " by ignoring the escape character \ and as such should be counted as 2 code lines and 1 comment. Some tools are unable to deal with this and instead count up to the "1.0.0" as a string which can cause the middle comment to be counted as code rather than a comment.

scc will also tell you the number of bytes it has processed (for most output formats) allowing you to estimate the cost of running some static analysis tools.

Usage

Command line usage of scc is designed to be as simple as possible. Full details can be found in scc --help or scc -h. Note that the below reflects the state of master not a release, as such features listed below may be missing from your installation.

$ scc -h
Sloc, Cloc and Code. Count lines of code in a directory with complexity estimation.
Version 4.0.0 (beta)
Ben Boyter <ben@boyter.org> + Contributors
Usage:   scc [flags] [files or directories]
Examples:   Count the current directory:     scc
Count a specific folder or file:     scc myproject/     scc main.go
Count several paths at once:     scc src/ docs/ README.md
Show a per-file breakdown instead of the per-language summary:     scc --by-file
Output as CSV or JSON (e.g. for further processing):     scc --format csv     scc --format json -o counts.json
Count an unrecognised extension as a known language:     scc --count-as jsp:html
Count files matching a path pattern as a new category (glob by default):     scc --count-as-pattern '*_spec.rb:Ruby Spec:Ruby'
Generate a self-contained HTML infographic report:     scc --report     scc --report=out.html --report-title "myrepo" --report-skip cocomo
Use a project config file (./.sccconfig) or a global one (precedence: global < project < CLI):     export SCCCONFIGPATH=~/.sccconfig     scc --config team.sccconfig
Flags:       --avg-wage int                        average wage value used for basic COCOMO calculation (default 56286)       --binary                              disable binary file detection       --buckets int                         time-bucket resolution for the git timeline reports (default 60) (default 60)       --by-author                           render the author rollup report (bus factor and last-toucher attribution over recent git history)       --by-file                             display output for every file   -m, --character                           calculate max and mean characters per line       --ci                                  enable CI output settings where stdout is ASCII       --cocomo-project-type string          change COCOMO model type [organic, semi-detached, embedded, "custom,1,1,1,1"] (default "organic")       --cognitive                           calculate cognitive (nesting-weighted) complexity       --config string                       load this file as the global config source; overrides SCCCONFIGPATH, honored even with --no-config       --cost-comparison                     show both COCOMO and LOCOMO estimates side by side       --count-as string                     count extension as language [e.g. jsp:htm,chead:"C Header" maps extension jsp to html and chead to C Header]       --count-as-pattern stringArray        count files matching a path pattern as a new named category backed by a base language [repeatable; pattern is glob by default, prefix with re: for regex; e.g. *_spec.rb:"Ruby Spec":Ruby or re:\.test\.js$:"JavaScript Tests":JavaScript]       --count-ignore                        set to allow .gitignore and .ignore files to be counted       --currency-symbol string              set currency symbol (default "$")       --debug                               enable debug output       --depth int                           commit window size for git history reports; 0 means entire history (large repos may be slow) (default 1000)       --directory-walker-job-workers int    controls the maximum number of workers which will walk the directory tree (default 8)   -a, --dryness                             calculate the DRYness of the project (implies --uloc)       --eaf float                           the effort adjustment factor derived from the cost drivers (1.0 if rated nominal) (default 1)       --exclude-dir strings                 directories to exclude (default [.git,.hg,.svn])   -x, --exclude-ext strings                 ignore file extensions (overrides include-ext) [comma separated list: e.g. go,java,js]   -n, --exclude-file strings                ignore files with matching names (default [package-lock.json,Cargo.lock,yarn.lock,pubspec.lock,Podfile.lock,pnpm-lock.yaml])       --file-gc-count int                   number of files to parse before turning the GC on (default 10000)       --file-list-queue-size int            the size of the queue of files found and ready to be read into memory (default 8)       --file-process-job-workers int        number of goroutine workers that process files collecting stats (default 8)       --file-summary-job-queue-size int     the size of the queue used to hold processed file statistics before formatting (default 8)       --find-root-config                    discover the project .sccconfig by walking up to the repository root instead of using ./.sccconfig   -f, --format string                       set output format [tabular, wide, json, json2, csv, csv-stream, cloc-yaml, html, html-table, sql, sql-insert, openmetrics] (default "tabular")       --format-multi string                 have multiple format output overriding --format [e.g. tabular:stdout,csv:file.csv,json:file.json]       --gen                                 identify generated files       --generated-markers strings           string markers in head of generated files (default [do not edit,<auto-generated />])   -h, --help                                help for scc       --hotspots                            render the hotspots report (files ranked by complexity × change frequency over recent git history)       --ignore-file stringArray             path to an additional gitignore-format ignore file, applied from the scan root; repeat to add more, later files and any in-tree ignore files take precedence   -i, --include-ext strings                 limit to file extensions [comma separated list: e.g. go,java,js]       --include-symlinks                    if set will count symlink files   -l, --languages                           print supported languages and extensions       --large-byte-count int                number of bytes a file can contain before being removed from output (default 1000000)       --large-line-count int                number of lines a file can contain before being removed from output (default 40000)       --locomo                              enable LOCOMO (LLM Output COst MOdel) cost estimation       --locomo-config string                LOCOMO power-user config "tokensPerLine,inputPerLine,complexityWeight,iterations,iterationWeight"       --locomo-cycles float                 override estimated LLM iteration cycles (default: calculated from complexity)       --locomo-input-price float            LOCOMO cost per 1M input tokens in dollars (overrides preset)       --locomo-output-price float           LOCOMO cost per 1M output tokens in dollars (overrides preset)       --locomo-preset string                LOCOMO model preset [large, medium, small, local] (default "medium")       --locomo-review float                 human review minutes per line of code for LOCOMO estimate (default 0.01)       --locomo-tps float                    LOCOMO output tokens per second (overrides preset)       --mcp                                 start as an MCP (Model Context Protocol) server over stdio       --min                                 identify minified files   -z, --min-gen                             identify minified or generated files       --min-gen-line-length int             number of bytes per average line for file to be considered minified or generated (default 255)       --no-cocomo                           remove COCOMO calculation output   -c, --no-complexity                       skip calculation of code complexity       --no-config                           disable auto-discovery of the SCCCONFIGPATH global and the project ./.sccconfig config   -d, --no-duplicates                       remove duplicate files from stats and output       --no-fold-authors                     disable the name+email-domain identity folding fallback for git author reports (mailmap still applied)       --no-gen                              ignore generated files in output (implies --gen)       --no-gitignore                        disables .gitignore file logic       --no-gitmodule                        disables .gitmodules file logic       --no-hborder                          remove horizontal borders between sections       --no-ignore                           disables .ignore file logic       --no-large                            ignore files over certain byte and line size set by large-line-count and large-byte-count       --no-min                              ignore minified files in output (implies --min)       --no-min-gen                          ignore minified or generated files in output (implies --min-gen)       --no-scc-ignore                       disables .sccignore file logic       --no-size                             remove size calculation output   -M, --not-match stringArray               ignore files and directories matching regular expression   -o, --output string                       output filename (default stdout)       --overhead float                      set the overhead multiplier for corporate overhead (facilities, equipment, accounting, etc.) (default 2.4)   -p, --percent                             include percentage values in output       --remap-all string                    inspect every file and remap by checking for a string and remapping the language [e.g. "-- C++ --":"C Header"]       --remap-unknown string                inspect files of unknown type and remap by checking for a string and remapping the language [e.g. "-- C++ --":"C Header"]       --report string[="scc-report.html"]   write a self-contained HTML report; bare flag writes scc-report.html and prompts before overwriting, --report=path/out.html overwrites silently       --report-skip string                  comma-separated sections to omit (cocomo,locomo,hotspots,authors,timeline,files,uloc,linelength,card)       --report-title string                 override the repo name shown in the report banner       --size-unit string                    set size unit [si, binary, mixed, xkcd-kb, xkcd-kelly, xkcd-imaginary, xkcd-intel, xkcd-drive, xkcd-bakers] (default "si")       --sloccount-format                    print a more SLOCCount like COCOMO calculation   -s, --sort string                         column to sort by [files, name, lines, blanks, code, comments, complexity] (default "files")       --sql-project string                  use supplied name as the project identifier for the current run. Only valid with the --format sql or sql-insert option       --timeline                            render an over-time view of recent git history; with --by-author runs the author timeline, alone runs the languages timeline   -t, --trace                               enable trace output (not recommended when processing multiple files)   -u, --uloc                                calculate the number of unique lines of code (ULOC) for the project   -v, --verbose                             verbose output       --version                             version for scc   -w, --wide                                wider output with additional statistics (implies --complexity)

Output should look something like the below for the redis project

$ scc redis 
───────────────────────────────────────────────────────────────────────────────
Language                 Files     Lines   Blanks  Comments     Code Complexity
───────────────────────────────────────────────────────────────────────────────
C                          437   267,353   31,103    45,998  190,252     48,269
JSON                       406    25,392        4         0   25,388          0
C Header                   288    48,831    5,648    11,302   31,881      3,097
TCL                        215    66,943    7,330     4,651   54,962      3,816
Shell                       75     1,626      239       343    1,044        185
Python                      34     4,802      694       498    3,610        621
Markdown                    26     4,647    1,226         0    3,421          0
Autoconf                    22    11,732    1,124     1,420    9,188      1,016
Lua                         20       525       69        71      385         89
Makefile                    20     1,956      368       170    1,418         85
YAML                        20     2,696      147        53    2,496          0
MSBuild                     11     1,995        2         0    1,993        160
Plain Text                  10     1,773      313         0    1,460          0
Ruby                         9       817       73       105      639        123
C++                          8       546       85        43      418         43
HTML                         5     9,658    2,928        12    6,718          0
License                      3        90       17         0       73          0
CMake                        2       298       49         5      244         12
CSS                          2       107       16         0       91          0
Systemd                      2        80        6         0       74          0
BASH                         1       143       16         5      122         38
Batch                        1        28        2         0       26          3
C++ Header                   1         9        1         3        5          0
Extensible Styleshe…         1        10        0         0       10          0
JavaScript                   1        31        1         0       30          5
Module-Definition            1    11,375    2,116         0    9,259        167
SVG                          1         1        0         0        1          0
Smarty Template              1        44        1         0       43          5
m4                           1       951      218        64      669          0
───────────────────────────────────────────────────────────────────────────────
Total                    1,624   464,459   53,796    64,743  345,920     57,734
───────────────────────────────────────────────────────────────────────────────
Estimated Cost to Develop (organic) $12,517,562
Estimated Schedule Effort (organic) 35.93 months
Estimated People Required (organic) 30.95
───────────────────────────────────────────────────────────────────────────────
Processed 16601962 bytes, 16.602 megabytes (SI)
───────────────────────────────────────────────────────────────────────────────

Note that you don't have to specify the directory you want to run against. Running scc will assume you want to run against the current directory.

You can also run against multiple files or directories scc directory1 directory2 file1 file2 with the results aggregated in the output.

Since scc writes to standard output, there are many ways to easily share the results. For example, using netcat and one of many pastebins gives a public URL:

$ scc | nc paste.c-net.org 9999
https://paste.c-net.org/Example

Ignore Files

scc supports .ignore files inside directories that it scans. This is similar to how ripgrep, ag and tokei work. .ignore files are 100% the same as .gitignore files with the same syntax, and as such scc will ignore files and directories listed in them. You can add .ignore files to ignore things like vendored dependency checked in files and such. The idea is allowing you to add a file or folder to git and have ignored in the count.

It also supports its own ignore file .sccignore if you want scc to ignore things while having ripgrep, ag, tokei and others support them.

You can also supply additional ignore files from outside the scanned tree with --ignore-file. The file uses the same gitignore syntax and its patterns are anchored at the scan root (so /build matches only the top-level build). This is handy for applying a shared ruleset such as a .dockerignore or a personal global ignore:

scc --ignore-file ~/.gitignore --ignore-file ./.dockerignore

The flag can be repeated and order matters: a later file can re-include something an earlier one ignored (via a ! negation), and any .gitignore, .ignore or .sccignore discovered inside the scanned tree takes precedence over everything supplied with --ignore-file.

If you want to apply your global git excludes file, point --ignore-file at it directly (for example --ignore-file ~/.config/git/ignore). scc deliberately does not shell out to git to discover it for you, but you can make it automatic by putting the flag in a .sccconfig configuration file and pointing the SCCCONFIGPATH environment variable at it, so every run picks it up without typing:

# ~/.config/scc/global.sccconfig
--ignore-file /home/me/.config/git/ignore

export SCCCONFIGPATH=~/.config/scc/global.sccconfig
scc   # now applies your global ignore on every run

Configuration Files

scc can read default flags from a configuration file to avoid creating shell aliases. The format is an opts-list in the style of ripgrep and bat: the file is simply a list of the same command-line flags you would otherwise type, and anything valid on the command line is valid in the file, with the exception of output flags.

Format rules:

• One flag per line is the recommended style, but multiple whitespace-separated tokens per line are allowed (--exclude-dir vendor).
• Lines use the normal -- prefix, e.g. --no-cocomo.
• # begins a comment. Whole-line and inline trailing comments are stripped.
• Blank lines are ignored.
• Tokenization is quote-aware, so both --exclude-dir vendor and --count-as 'jsp:html' work. Quotes (single or double) are the only grouping mechanism; to include a literal quote, switch quote style (--count-as "a'b").
• Backslash is an ordinary literal, not an escape character, so a Windows path such as --exclude-dir C:\build\out survives verbatim.
• A line whose first token does not start with - (a bare positional such as src/) is skipped with a warning, so a config file cannot inject extra count targets.

# count the way I like it
--no-cocomo
--exclude-dir vendor,node_modules
--format wide          # default to the wider table

Sources and discovery

There are two configuration tiers:

• Global — there is no fixed default location and no per-run home-directory stat. The global source is consulted only when set explicitly via the SCCCONFIGPATH environment variable or the --config <path> flag. --config which overrides SCCCONFIGPATH.
• Project — a file named .sccconfig in the current working directory (./.sccconfig), found with a single stat and no walk-up. cd project && scc picks up project/.sccconfig; running scc from a subdirectory does not pick up an ancestor's .sccconfig. Path arguments do not move the anchor — scc ./project still reads ./.sccconfig, not ./project/.sccconfig.

Precedence

Lowest to highest, later wins: global config < project config < command line. Scalar and boolean flags follow last-wins, so the command line always overrides config.

Slice flags (--exclude-dir, --exclude-file, --exclude-ext, --include-ext, --not-match) union instead of overriding:

config: --exclude-dir vendor
CLI:    --exclude-dir dist
result: vendor, dist

The three slice flags that ship with built-in defaults — --exclude-dir (.git, .hg, .svn), --exclude-file (the lockfile set) and --generated-markers — keep those defaults as a non-removable safety net: a config or CLI value is added to the defaults rather than replacing them, so putting vendor in .sccconfig never stops scc skipping .git.

Config can never write a file

A configuration file can change how scc counts and formats, including selecting a stdout format such as --format json, but it can never cause scc to write a file. The file-output flags — --output / -o, --report and --format-multi — are honoured only from the command line; the same flags supplied by config are ignored (output goes to stdout, the default). This is because a project .sccconfig is auto-discovered, so a cloned repository could otherwise silently overwrite one of your files. Only the command line can make scc write to disk.

Control flags

| Flag | Effect | |------|--------| | --no-config | Disable auto-discovery: skip the SCCCONFIGPATH global and the project .sccconfig. | | --config <path> | Load this file as the global source. Always honoured, even with --no-config; overrides SCCCONFIGPATH. | | --find-root-config | Discover the project .sccconfig by walking up to the repository root instead of using ./.sccconfig. No-op under --no-config. |

--config test.sccconfig --no-config loads exactly test.sccconfig and nothing else — a clean isolated-config mode. A --config or --no-config written inside a config file is inert (a config file cannot chain-load another config file).

The @file argument bundle

scc @flags.txt expands the contents of flags.txt as if its lines had been typed on the command line. It uses the same opts-list tokenizer as config files (comments, quotes, backslash-literal), but unlike config files it keeps positional paths and may write files — an @file is an explicit, user-supplied argument bundle equivalent to typing the flags, so it is trusted like the command line (including a --config inside it being honoured). @file expansion fires only when @file is the sole argument.

Note that because config discovery now runs on the post-@file arguments, scc @flags.txt in a directory containing ./.sccconfig loads both — the @file tokens sit above the config in precedence. To get the old "exactly these args, nothing else" behaviour, add --no-config.

Interesting Use Cases

Used inside Intel Nemu Hypervisor to track code changes between revisions Appears to also be used inside both

It also is used to count code and guess language types in which makes it one of the most frequently run code counters in the world.

You can also hook scc into your gitlab pipeline

Used by the following products and services,

• GitHub CodeQL - The CodeQL engine uses scc for line counting
• JetBrains Qodana - The Qodana CLI leverages scc as a command-line helper for code analysis
• Scaleway - Cloud provider using scc
• Linux Foundation LFX Insights - COCOMO cost estimation
• OpenEMS

Features

scc uses a small state machine in order to determine what state the code is when it reaches a newline \n. As such it is aware of and able to count

• Single Line Comments
• Multi Line Comments
• Strings
• Multi Line Strings
• Blank lines

It also attempts to count the complexity of code. This is done by checking for branching operations in the code. For example, each of the following for if switch while else || && != == if encountered in Java would increment that files complexity by one.

Complexity Estimates

Let's take a minute to discuss the complexity estimate itself.

The complexity estimate is really just a number that is only comparable to files in the same language. It should not be used to compare languages directly without weighting them. The reason for this is that its calculated by looking for branch and loop statements in the code and incrementing a counter for that file.

Because some languages don't have loops and instead use recursion they can have a lower complexity count. Does this mean they are less complex? Probably not, but the tool cannot see this because it does not build an AST of the code as it only scans through it.

Generally though the complexity there is to help estimate between projects written in the same language, or for finding the most complex file in a project scc --by-file -s complexity which can be useful when you are estimating on how hard something is to maintain, or when looking for those files that should probably be refactored.

As for how it works.

It's my own definition, but tries to be an approximation of cyclomatic complexity although done only on a file level.

The reason it's an approximation is that it's calculated almost for free from a CPU point of view (since its a cheap lookup when counting), whereas a real cyclomatic complexity count would need to parse the code. It gives a reasonable guess in practice though even if it fails to identify recursive methods. The goal was never for it to be exact.

In short when scc is looking through what it has identified as code if it notices what are usually branch conditions it will increment a counter.

The conditions it looks for are compiled into the code and you can get an idea for them by looking at the JSON inside the repository. See for an example of what it's looking at for a file that's Java.

The increment happens for each of the matching conditions and produces the number you see.

Unique Lines of Code (ULOC)

ULOC stands for Unique Lines of Code and represents the unique lines across languages, files and the project itself. This idea was taken from where the calculation is presented using standard Unix tools sort -u .h .c | wc -l. This metric is there to assist with the estimation of complexity within the project. Quoting the source

In my opinion, the number this produces should be a better estimate of the complexity of a project. Compared to SLOC, not only are blank lines discounted, but so are close-brace lines and other repetitive code such as common includes. On the other hand, ULOC counts comments, which require just as much maintenance as the code around them does, while avoiding inflating the result with license headers which appear in every file, for example.

You can obtain the ULOC by supplying the -u or --uloc argument to scc.

It has a corresponding metric DRYness % which is the percentage of ULOC to CLOC or DRYness = ULOC / SLOC. The higher the number the more DRY (don't repeat yourself) the project can be considered. In general a higher value here is a better as it indicates less duplicated code. The DRYness metric was taken from a comment by minimax uniquelines_code>

To obtain the DRYness metric you can use the -a or --dryness argument to scc, which will implicitly set --uloc.

Note that there is a performance penalty when calculating the ULOC metrics which can double the runtime.

Running the uloc and DRYness calculations against C code a clone of redis produces an output as follows.

$ scc -a -i c redis 
───────────────────────────────────────────────────────────────────────────────
Language                 Files     Lines   Blanks  Comments     Code Complexity
───────────────────────────────────────────────────────────────────────────────
C                          437   267,353   31,103    45,998  190,252     48,269
(ULOC)                            149892
───────────────────────────────────────────────────────────────────────────────
Total                      437   267,353   31,103    45,998  190,252     48,269
───────────────────────────────────────────────────────────────────────────────
Unique Lines of Code (ULOC)       149892
DRYness %                           0.56
───────────────────────────────────────────────────────────────────────────────
Estimated Cost to Develop (organic) $6,681,762
Estimated Schedule Effort (organic) 28.31 months
Estimated People Required (organic) 20.97
───────────────────────────────────────────────────────────────────────────────
Processed 9390815 bytes, 9.391 megabytes (SI)
───────────────────────────────────────────────────────────────────────────────

Further reading about the ULOC calculation can be found at

Interpreting Dryness,

• 75% (High Density): Very terse, expressive code. Every line counts. (Example: Clojure, Haskell)
• 60% - 70% (Standard): A healthy balance of logic and structural ceremony. (Example: Java, Python)
• < 55% (High Boilerplate): High repetition. Likely due to mandatory error handling, auto-generated code, or verbose configuration. (Example: C#, CSS)

Estimated Cost to Develop (organic) $664,081
Estimated Schedule Effort (organic) 11.772217 months
Estimated People Required (organic) 5.011633

scc --cocomo-project-type organic
scc --cocomo-project-type semi-detached
scc --cocomo-project-type embedded

scc --cocomo-project-type "custom,1,1,1,1"

$ scc --locomo .
...
LOCOMO LLM Cost Estimate (medium)
  Tokens Required (in/out) 3.0M / 0.7M
  Cost to Generate $20
  Estimated Cycles 2.1
  Generation Time (serial) 3.9 hours
  Human Review Time 5.9 hours
  Disclaimer: rough ballpark for regenerating code using a LLM.
  Does not account for context reuse, test generation, or heavy debugging.

scc --locomo --locomo-preset large .
scc --locomo --locomo-preset local .

scc --locomo --locomo-input-price 1.0 --locomo-output-price 5.0 .
scc --locomo --locomo-tps 100 .

scc --locomo --locomo-review 0.05 .
scc --locomo --locomo-review 0.1 .

scc --locomo --locomo-config "tokensPerLine,inputPerLine,complexityWeight,iterations,iterationWeight"

scc --locomo --locomo-config "8,15,3,2.0,1.5"

scc --cost-comparison .

$ scc --hotspots
───────────────────────────────────────────────────────────────────────────────
Hotspots · last 500 commits · 2024-01-09 → 2026-05-20
───────────────────────────────────────────────────────────────────────────────
File                            Lang   Cmplx  Commits   Lines±  Authrs  Hotspot
───────────────────────────────────────────────────────────────────────────────
processor/workers.go              Go     488       62    7,240       9    100.0
processor/processor.go            Go     402       41    3,910       7     71.4
processor/formatters.go           Go     233       38    2,980       6     51.8
main.go                           Go     180       44    2,510       8     48.2
───────────────────────────────────────────────────────────────────────────────
   complexity × change-frequency, normalised · 20 of 142 files shown
───────────────────────────────────────────────────────────────────────────────

$ scc --by-author
───────────────────────────────────────────────────────────────────────────────
Authors · last 500 commits · 2024-01-09 → 2026-05-20
───────────────────────────────────────────────────────────────────────────────
Author                               Code     Cmplx   Files     Owns  Last seen
───────────────────────────────────────────────────────────────────────────────
Alice Smith                         24,110     4,180     118    38.6%  2026-05-22
Bob Jones                           15,447     1,902      74    24.7%  2026-03-14
Carol Lee                            9,205     3,640      51    14.7%  2026-05-19
(before window)                      6,540       810      29    10.4%          -
others (12)                          1,300       190       -     2.1%          -
───────────────────────────────────────────────────────────────────────────────
Bus factor 2 · Alice + Bob last-touched 63% of in-window code
───────────────────────────────────────────────────────────────────────────────

$ scc --by-author --timeline
───────────────────────────────────────────────────────────────────────────────
Authors · last 500 commits · 2024-01-09 → 2026-05-20
───────────────────────────────────────────────────────────────────────────────
Author                   Activity                  Commits     Code±
───────────────────────────────────────────────────────────────────────────────
Alice Smith              ▂▃▅▇█▇▆▅▄▄▃▃                   210      +38k
Bob Jones                ▇█▆▄▂▁▁▁▁▁▁▁                   142      +21k  quiet 2mo
Carol Lee                ▁▁▁▁▂▃▄▅▆▇██                    96      +14k  ↑
───────────────────────────────────────────────────────────────────────────────

$ scc --timeline
───────────────────────────────────────────────────────────────────────────────
Languages · last 500 commits · 2024-01-09 → 2026-05-20
───────────────────────────────────────────────────────────────────────────────
Language             Trend                             Code    Share     Change
───────────────────────────────────────────────────────────────────────────────
TypeScript           ▁▁▂▃▄▅▆▇████                     36,840    58.0%    +36,840
Go                   ▃▃▄▄▅▅▅▆▆▆▆▆                     24,110    38.0%     +9,205
JavaScript           ██▇▆▅▄▃▂▁▁▁▁                      2,540     4.0%    -18,300
Markdown             ▂▃▃▄▄▅▅▆▆▆▇▇                      1,204     1.9%       +994
───────────────────────────────────────────────────────────────────────────────

$ scc --report                       # writes scc-report.html (prompts before overwriting)
$ scc --report=docs/code.html        # explicit path; overwrites silently