scc
Sloc Cloc and Code, a very fast accurate code counter with complexity calculations and COCOMO estimates
About scc
This large README is shown as a plain-text preview. Read the full README at the source
# Sloc Cloc and Code (scc)  > scc powers [searchcode.com](https://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`. [](https://github.com/boyter/scc/actions/workflows/go.yml) [](https://coveralls.io/github/boyter/scc?branch=master) [](https://github.com/boyter/scc/)  [](https://github.com/avelino/awesome-go) Licensed under MIT licence. ## Table of Contents - [Install](#install) - [Background](#background) - [Pitch](#pitch) - [Usage](#usage) - [Configuration Files](#configuration-files) - [Complexity Estimates](#complexity-estimates) - [Unique Lines of Code (ULOC)](#unique-lines-of-code-uloc) - [COCOMO](#cocomo) - [LOCOMO](#locomo) - [Git Insight Reports](#git-insight-reports) - [HTML Report](#html-report) - [Output Formats](#output-formats) - [Performance](#performance) - [Development](#development) - [MCP Server Mode](#mcp-server-mode) - [Adding/Modifying Languages](#addingmodifying-languages) - [Issues](#issues) - [Badges](#badges) - [Language Support](LANGUAGES.md) - [Citation](#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](https://docs.google.com/forms/d/e/1FAIpQLScIBKy3y2m0rKu89L67qwe26Xyn9Scu0gW-HQX9lC0qEAx9nQ/viewform) ### 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/v4@latest` To install a development version: `go install github.com/boyter/scc/v4@master` Note that `scc` needs go version >= 1.25. #### Snap A [snap install](https://snapcraft.io/scc) exists thanks to [Ricardo](https://feliciano.tech/). `$ sudo snap install scc` *NB* Snap installed applications cannot run outside of `/home` <https://askubuntu.com/questions/930437/permission-denied-error-when-running-apps-installed-as-snap-packages-ubuntu-17> so you may encounter issues if you use snap and attempt to run outside this directory. #### Homebrew Or if you have [Homebrew](https://brew.sh/) installed `$ brew install scc` #### Fedora Fedora Linux users can use a [COPR repository](https://copr.fedorainfracloud.org/coprs/lihaohong/scc/): `$ sudo dnf copr enable lihaohong/scc && sudo dnf install scc` #### MacPorts On macOS, you can also install via [MacPorts](https://www.macports.org) `$ sudo port install scc` #### Scoop Or if you are using [Scoop](https://scoop.sh/) on Windows `$ scoop install scc` #### Chocolatey Or if you are using [Chocolatey](https://chocolatey.org/) on Windows `$ choco install scc` #### WinGet Or if you are using [WinGet](https://github.com/microsoft/winget-cli) 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: ```bash 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 x86_64 machines are available from the [releases](https://github.com/boyter/scc/releases) page. #### GitLab <https://about.gitlab.com/blog/2023/02/15/code-counting-in-gitlab/> #### Other If you would like to assist with getting `scc` added into apt/chocolatey/etc... please submit a PR or at least raise an issue with instructions. ### Background Read all about how it came to be along with performance benchmarks, - <https://boyter.org/posts/sloc-cloc-code/> - <https://boyter.org/posts/why-count-lines-of-code/> - <https://boyter.org/posts/sloc-cloc-code-revisited/> - <https://boyter.org/posts/sloc-cloc-code-performance/> - <https://boyter.org/posts/sloc-cloc-code-performance-update/> Some reviews of `scc` - <https://nickmchardy.com/2018/10/counting-lines-of-code-in-koi-cms.html> - <https://www.feliciano.tech/blog/determine-source-code-size-and-complexity-with-scc/> - <https://metaredux.com/posts/2019/12/13/counting-lines.html> Setting up `scc` in GitLab - <https://about.gitlab.com/blog/2023/02/15/code-counting-in-gitlab/> A talk given at the first GopherCon AU about `scc` (press S to see speaker notes) - <https://boyter.org/static/gophercon-syd-presentation/> - <https://www.youtube.com/watch?v=jd-sjoy3GZo> For performance see the [Performance](https://github.com/boyter/scc#performance) section Other similar projects, - [SLOCCount](https://www.dwheeler.com/sloccount/) the original sloc counter - [cloc](https://github.com/AlDanial/cloc), inspired by SLOCCount; implemented in Perl for portability - [gocloc](https://github.com/hhatto/gocloc) a sloc counter in Go inspired by tokei - [loc](https://github.com/cgag/loc) rust implementation similar to tokei but often faster - [loccount](https://gitlab.com/esr/loccount) Go implementation written and maintained by ESR - [mezura](https://github.com/subamanis/mezura) fast code counter in C++ - [polyglot](https://github.com/vmchale/polyglot) ATS sloc counter - [tokei](https://github.com/XAMPPRocky/tokei) fast, accurate and written in rust - [sloc](https://github.com/flosse/sloc) coffeescript code counter - [stto](https://github.com/mainak55512/stto) new Go code counter with a focus on performance - [linejudge](https://github.com/loc-conformance/linejudge) conformance and differential testing suite for line counters - [linebench](https://github.com/loc-conformance/linebench) multi-counter performance and resource benchmark suite Interesting reading about other code counting projects tokei, loc, polyglot and loccount - <https://www.reddit.com/r/rust/comments/59bm3t/a_fast_cloc_replacement_in_rust/> - <https://www.reddit.com/r/rust/comments/82k9iy/loc_count_lines_of_code_quickly/> - <http://blog.vmchale.com/article/polyglot-comparisons> - <http://esr.ibiblio.org/?p=8270> Further reading about processing files on the disk performance - <https://blog.burntsushi.net/ripgrep/> Using `scc` to process 40 TB of files from GitHub/Bitbucket/GitLab - <https://boyter.org/posts/an-informal-survey-of-10-million-github-bitbucket-gitlab-projects/> ### 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! <https://github.com/boyter/scc/issues/115> - 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 Why not use `scc`? - You don't like Go for some reason - It cannot count D source with different nested multi-line comments correctly <https://github.com/boyter/scc/issues/27> ### 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, ```c /* 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, ```C# 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. ```text $ scc -h Sloc, Cloc and Code. Count lines of code in a directory with complexity estimation. Version 4.1.0 Ben Boyter <[email protected]> + Contributors https://github.com/boyter/scc 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 SCC_CONFIG_PATH=~/.sccconfig scc --config team.sccconfig Tune the COCOMO cost estimate, or turn it off (see https://en.wikipedia.org/wiki/COCOMO): scc --avg-wage 75000 --cocomo-project-type semi-detached scc --no-cocomo 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) --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 SCC_CONFIG_PATH, 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 --count-unsupported count files with an unrecognised language under an "Unknown" category as plain text --coupling render the change-coupling report (file pairs that change together over recent git history) --coupling-for string blast-radius view: given a file path, show what tends to change with it over recent git history --coupling-weighted weight coupling by file complexity so pairs of complex files rank above generated/data-file churn (implies --coupling) --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]) --exp-per-language-counters experimental, may change or be removed: count with the scanner written for the file's language where there is one, see --list-counters --file-gc-count int number of files to parse before turning the GC on (default 10000) --file-list-job-workers int number of goroutine workers that turn a walked path into a job to be counted (default 8) --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) --list-counters print the languages that have a scanner of their own and exit --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 SCC_CONFIG_PATH 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)
Frequently Asked Questions
What is scc?
scc is a Software Packages library for the Go programming language. Sloc Cloc and Code, a very fast accurate code counter with complexity calculations and COCOMO estimates
How many GitHub stars does scc have?
scc has 8,813 GitHub stars in the directory's latest synchronization.
How do I install scc?
Install scc with the Go module system using `go get boyter/scc`. Check the repository for the current installation instructions.
What category does scc belong to?
scc is listed under Software Packages, specifically Other Software.