> ## Documentation Index
> Fetch the complete documentation index at: https://docs.qlty.sh/llms.txt
> Use this file to discover all available pages before exploring further.

# Changelog

> New features, improvements, and fixes across Qlty Cloud and the Qlty CLI

**October 29, 2026**

## Java plugins run on Java 25

Java-based plugins such as Checkstyle, PMD and radarlint can fetch configs or rulesets over HTTPS while they run. The CLI's previous default Java, Temurin 22.0.1+8, still trusts the compromised eMudhra certificate authorities, so it would accept a forged certificate.

Starting with CLI v0.664.0, the default Java runtime is Temurin 25.0.5+8, which rejects those certificates. Qlty Cloud picks up the new CLI automatically. See the [security advisory](https://github.com/qltysh/qlty/security/advisories/GHSA-f55x-97q4-pfrc) for details.

If you followed the advisory and added `java = "25.0.5+8"` under `[runtimes.enabled]`, you can remove it. Any other Java version you pin stays in effect. See [Runtimes](https://docs.qlty.sh/cli/concepts/runtimes.md).

## radarlint-kotlin 2.1.0 reports more Kotlin issues

radarlint-kotlin moves to 2.1.0. It bundles a newer SonarSource Kotlin analyzer that runs on Java 25. The new analyzer resolves the types in your code, so existing rules find issues the old one missed. It also parses newer Kotlin syntax, such as guards in `when` branches, so files the old one skipped now get analyzed.

Expect more Kotlin issues on your default branch. In our tests on open source projects, the count rose by 4% to 15%. Pull requests flag only the issues on lines they add, so code a PR doesn't touch adds nothing to it.

Three rules report false positives with the new analyzer:

* **`kotlin:S1128` (unused imports)** flags imports used only in annotations or KDoc, and imports that share a name with a local declaration. SonarSource's later Kotlin analyzers no longer report this rule.
* **`kotlin:S1862` (same condition in related branches)** ignores `when` guards, so it flags branches that differ only in their guard.
* **`kotlin:S6619` (useless null checks)** flags some null checks on map lookups that can return null.

To turn a rule off, add a line to `radarlint.properties` in your project root:

```properties radarlint.properties lines theme={"system"}
radarlint.rules.kotlin.S1128=false
```

See [Radarlint Configuration](https://docs.qlty.sh/cli/radarlint-configuration.md).

## Pinned plugin versions that fail on Java 25

* **radarlint-kotlin 2.0.0 and earlier** analyze nothing on Java 25 and report no error. Upgrade to 2.1.0.
* **google-java-format 1.26.0 and earlier** crash on Java 25. Upgrade to 1.27.0 or later.

If you can't upgrade yet, pin `java = "22.0.1+8"` under `[runtimes.enabled]`. Java 22 still trusts the compromised certificate authorities, so remove the pin as soon as you upgrade.

**October 13, 2026**

## Automatic coverage setup

Setting up coverage reporting on CI usually goes in a loop. You add the upload step, push, and wait for the test suite. A flag or a path is wrong, so you fix it, push, and wait again. Automatic coverage setup hands that work to Qlty Cloud's agent.

Open **Project Settings → Code Coverage**, click **Set up coverage**, and on the **Automatic** tab click **Set up automatically**. A few minutes later there's a draft PR titled **Set up Qlty code coverage** on your repository, with the agent's report as its description. Review it and merge it, and the next CI run on your default branch sends coverage.

The agent runs in an isolated build container with a copy of your default branch. It reads your CI configuration and test setup, and writes the smallest change that produces complete coverage. On GitHub Actions it uses OIDC, so there's no secret to add. It can't commit, push, add secrets or merge. Qlty turns its edits into the PR.

We've tested it on GitHub Actions. On CircleCI and other providers, review the PR with extra care. If the PR's CI fails, the same page lets you run Qlty's open source [`setup-coverage` skill](https://github.com/qltysh/qlty-skills/tree/main/skills/setup-coverage) in your own coding agent, or set coverage up by hand.

Starting a run needs the **admin** role on the project, and the [Qlty GitHub App](https://docs.qlty.sh/cloud/github-app.md) needs the **Workflows** permission. If it's missing, the setup page links to where an organization owner can [accept it](https://docs.qlty.sh/cloud/github-app.md#accepting-new-permissions). To set up coverage, Qlty sends your repository's default branch to an AI subprocessor, currently Anthropic, which does not train models on it. See [Data Usage](https://docs.qlty.sh/cloud/data-usage.md).

See [Automatic Coverage Setup](https://docs.qlty.sh/coverage/automatic-setup.md) for details.

**August 31, 2026**

## Is the code your team is shipping well covered?

Most coverage trend charts plot a Project's total coverage over time. That's valuable, but on a large project total coverage is a lagging metric: a real change in how a team tests takes a long time to make a meaningful mark on the total. Diff coverage — the coverage of the lines a change touches — is a leading one. If your team is covering the code it ships, diff coverage is high now, and total coverage trends upward over time.

Every Project's **Trends** page now includes a **Diff Coverage** chart, showing how well tested the code you merged was, week by week. Diff coverage is plotted as a line, with the executable lines changed in each period as bars behind it, so you can tell a meaningful week from a quiet one. Ranges run from 1 month to 3 years.

There's nothing to configure — the chart is built from the coverage you already upload on your default branch. See [Diff Coverage Over Time](https://docs.qlty.sh/coverage/diff-coverage-trends.md) for details.

**August 5, 2026**

## Build Secrets (beta)

Some linters need a credential to do their job: an API token to reach a private package registry, a license key for a commercial tool. Until now, there was no way to hand one to a cloud build without committing it to your repository.

**Build Secrets** are encrypted environment variables you set per project. Open **Project Settings → Secrets**, add a name and a value, and it's available to that project's builds. Values are write-only — once saved, a secret is encrypted and can never be read back, only rotated or deleted. The list shows names and timestamps, and only project admins can see or change it.

Adding a secret doesn't hand it to every plugin. The Qlty CLI runs each plugin in a subprocess with a restricted environment and passes through only the variables that plugin's definition names, so you opt each plugin in from your `qlty.toml`:

```toml theme={"system"}
[[plugins.definitions.foo.environment]]
name = "BAR"
value = "${env.BAR}"
```

Secrets reach your plugins only while Qlty installs and runs them, and never reach builds for pull requests from forks.

Build Secrets are in beta and rolled out per workspace — [contact Qlty Support](https://qlty.sh/contact/support) to request access. See [Build Secrets](https://docs.qlty.sh/cloud/build-secrets.md) for details.

**July 23, 2026**

## Selective Coverage on pull requests (beta)

Qlty has always supported partial test runs through [tags](https://docs.qlty.sh/coverage/tags.md). Publish your unit tests as `units` and that suite is tracked on its own, because a tag runs a predictable set of tests each time and every report for it is comparable to the last.

Test optimization tools break that assumption. To keep pull request builds fast on a large codebase, they choose a different subset of tests for every build based on what the change touched. Each report covers a unique slice of the codebase, comparable to nothing before it, and to a coverage tool it looks like a sudden, dramatic drop. The coverage such a run reports would be misleading, so our recommendation has been not to publish it at all.

**Selective Coverage** makes those runs usable by overlaying the selected report on the pull request's diff. Add `--selection` to `qlty coverage publish` in the builds that run a dynamically selected subset of your tests:

```bash Qlty CLI lines theme={"system"}
qlty coverage publish --selection coverage/lcov.info
```

```yaml GitHub Action lines theme={"system"}
- uses: qltysh/qlty-action/coverage@v2
  with:
    token: ${{ secrets.QLTY_COVERAGE_TOKEN }}
    files: coverage/lcov.info
    selected: true
```

Qlty trusts a selected report for the lines it does cover — exactly what diff coverage needs — so the Diff Coverage commit status and PR comments work as usual. The Total Coverage status passes with "Not computable for select coverage" rather than a misleading percentage; total coverage metrics, component coverage, trends, and the file explorer are untouched; and a selected report is never used as the comparison base for another pull request.

Selective Coverage is in beta and requires Qlty CLI v0.633.0, GitHub Action `qltysh/qlty-action` v2.3.0, or CircleCI orb `qltysh/qlty-orb` 0.1.2 — or newer. Publish full-suite coverage on your default branch to keep totals and baselines accurate. See [Selective Coverage](https://docs.qlty.sh/coverage/selective-coverage.md) for details.

**June 12, 2026**

## Seat-based licensing

Qlty Cloud now licenses Workspaces by **seats** instead of active contributors. A new **Seat Management** settings page lets admins assign seats to contributors and see how many are in use. See [Seats](https://docs.qlty.sh/cloud/billing/seats.md) for details.

## Verified seat assignment

When you assign a seat on the Seat Management page, Qlty now verifies the GitHub username exists before granting the seat. A confirmation dialog shows the account's avatar, name, and whether they belong to your GitHub organization, so you can catch typos and confirm you're assigning the right person. Non-existent accounts are rejected before any seat is used.

## Search when adding projects

The Add Projects page now has a search box that filters across all accessible repositories server-side, so you no longer have to page through every repo to find one in a large Workspace.

## `--skip-source-fetch` for `qlty coverage publish`

`qlty coverage publish` now accepts `--skip-source-fetch`, matching `qlty check` and `qlty fmt`. When set, the command skips fetching remote sources and falls back to the default configuration if a source is not cached locally. See [coverage publish](https://docs.qlty.sh/cli/commands/coverage-publish.md) for details.

## VB.NET maintainability analysis

The Qlty CLI now analyzes `.vb` files for maintainability — complexity, duplication, and code smells — with VB.NET's case-insensitive member semantics handled correctly.

## Scala maintainability analysis

The Qlty CLI now analyzes Scala (including Scala 3) source files for maintainability — complexity, duplication, and code smells.

## Knip honors `.qlty/configs/`

Fixed Knip not picking up a configuration file placed under `.qlty/configs/` in nested-package layouts. Qlty now passes the config path to Knip explicitly.

## RuboCop `AllCops: Exclude` now respected

Qlty now passes `--force-exclusion` to RuboCop, so `AllCops: Exclude` patterns in your `.rubocop.yml` are honored even though Qlty invokes RuboCop with explicit file targets.

## editorconfig-checker findings no longer dropped

Fixed a bug where `editorconfig-checker` results were silently discarded when the tool reported a `-1` line number for an issue it couldn't locate. All findings are now reported.

**June 2, 2026**

## Verified CLI downloads in GitHub Actions

The Qlty GitHub Actions now verify the Qlty CLI's Sigstore attestation before running it. Each action checks the downloaded archive against its signed provenance using the GitHub CLI, giving your workflows tamper-evident assurance that the binary came from Qlty. Verification is automatic and uses your existing `${{ github.token }}`.

See [Integrity Verification](https://docs.qlty.sh/cli/integrity-verification.md) for details.

## More coverage formats in the GitHub Action

The Qlty coverage GitHub Action now accepts `dotcover` and `xccov-json` as `format` values, so you can upload JetBrains dotCover and Xcode `xccov` JSON reports directly from your workflow without converting them first.

See [Generating Coverage Data](https://docs.qlty.sh/coverage/generating-data.md) for details.

## Node 24 runtime for GitHub Actions

The Qlty GitHub Actions now run on the Node 24 runtime, clearing the deprecation warning GitHub showed for the older Node 20 runtime and keeping the actions on a supported runtime ahead of GitHub's automatic migration.

## Windows support for the fmt action

The Qlty `fmt` GitHub Action now runs on Windows runners in addition to Linux and macOS, so Windows-based CI pipelines can auto-format code with Qlty.

**April 15, 2026**

## C and C++ language support

Qlty now provides maintainability analysis for C and C++. This includes complexity, duplication, and code smells, available in both the Qlty CLI and Qlty Cloud. See [C / C++](https://docs.qlty.sh/languages/c-cpp.md) for details.

## Travis CI push branch detection

Travis CI users no longer need to set the branch name manually when uploading coverage. The Qlty CLI now detects the branch automatically on Travis push builds, the same way it already does for other CI providers.

**April 9, 2026**

## editorconfig-checker plugin

We've added a plugin for [editorconfig-checker](https://github.com/editorconfig-checker/editorconfig-checker), which verifies that your codebase follows the rules defined in `.editorconfig`.

```bash lines theme={"system"}
qlty plugins enable editorconfig-checker
```

**March 24, 2026**

## Spectral plugin

We've added a plugin for [Spectral](https://github.com/stoplightio/spectral), a linter for OpenAPI and AsyncAPI specifications.

```bash lines theme={"system"}
qlty plugins enable spectral
```

**March 18, 2026**

## golangci-lint v2 support

The Qlty plugin for [golangci-lint](https://golangci-lint.run/) now supports the v2 output format in addition to v1, so you can upgrade golangci-lint without losing report parsing.

**March 17, 2026**

## Client-side coverage summing

The Qlty CLI can now sum multiple coverage reports on the client before upload, complementing our existing server-side coverage merging. This is useful in CI workflows that already collect multiple coverage files on a single machine.

**March 5, 2026**

## Resync renamed repositories

When a GitHub repository is renamed, you can now click a **Resync** button on the Add Project page to update Qlty's reference to the new repository name, keeping the Project's existing history and settings instead of having to re-add it from scratch.

**February 14, 2026**

## Python 3.13+ support

The Qlty CLI now supports multiple Python runtime releases, enabling Python 3.13 and newer for plugins that require recent Python versions.

**February 5, 2026**

## On-demand source fetching

You now have precise control over when private sources are loaded — useful in offline or air-gapped environments, and for pre-fetching sources once in CI before running multiple analyses. A new `qlty sources fetch` command fetches the sources defined in `qlty.toml` without running analysis, and a new `--skip-source-fetch` flag tells `qlty check` and `qlty fmt` to use what's already on disk.

```bash lines theme={"system"}
qlty sources fetch
qlty check --skip-source-fetch
qlty fmt --skip-source-fetch
```

**January 29, 2026**

## SLSA provenance for installers and upgrades

Qlty CLI installer scripts are now published with [SLSA](https://slsa.dev/) attestations, and the `qlty upgrade` command verifies SLSA provenance for new releases using the `gh` CLI. This adds an extra layer of supply-chain integrity to installations and upgrades.

**January 26, 2026**

## Improved SAML re-authentication

When a user accessing a Workspace with SAML enabled needs to re-authenticate, Qlty Cloud now surfaces a clearer re-authentication page with explicit instructions, rather than a generic error.

**January 24, 2026**

## Always-available PR Coverage tab

The Pull Request Coverage tab now renders even when a base coverage report is missing, so reviewers always have a coverage view to work from. When there is no base report, diff coverage is displayed as "N/A" rather than blocking the page.

**January 20, 2026**

## Better missing coverage data messaging

When a Project is missing expected coverage data, the Coverage page now displays a clearer message explaining what's missing and how to resolve it.

**January 8, 2026**

## HTTPS required for all outgoing requests

The Qlty CLI now requires HTTPS for all outgoing HTTP requests, including source fetching and tool downloads. All network activity from the CLI is encrypted in transit.

**December 26, 2025**

## Jenkins CI auto-detection

We now support automatic detection of build metadata from Jenkins. Uploading coverage from a Jenkins build only requires the path to the coverage data file. See [setting up coverage with Jenkins](https://docs.qlty.sh/coverage/ci.md) for the full walkthrough.

```shell lines theme={"system"}
qlty coverage publish coverage.lcov
```

**December 19, 2025**

## Coverage page redesign

A clearer view of how a pull request moves your coverage. The Project Coverage page has been rebuilt from the ground up, with:

* Improved stats cards
* A Files Changed tab with rendered file diffs
* A Components tab showing per-Component coverage for the pull request
* A collapsible sidebar with coverage comparison details

**December 5–12, 2025**

## Coverage summary comment improvements

Coverage summary comments on pull requests have been redesigned. The new comment includes:

* An updated rating display
* A **Modified Components** section showing which Components changed in the pull request
* An **AI prompt** section with a ready-to-paste prompt for your AI coding agent to write the missing tests
* The Qlty header image and clearer formatting

**December 10–12, 2025**

## More coverage formats supported

The Qlty CLI now ingests two more coverage report variants without any conversion step:

* Apple's `xccov-json` format produced by `xccov` from Xcode coverage data
* JaCoCo reports containing `<group>` elements, the standard output for multi-module Maven and Gradle projects

**December 1–4, 2025**

## Coverage Report page

Full visibility into how each commit's coverage report was built — and a way to clean it up when something goes wrong. Qlty Cloud now includes a Coverage Report details page for each commit, showing summary metrics and every upload that contributed to the report. Project admins can also delete individual reports or uploads from Coverage Settings when a bad upload needs to be removed.

**December 1, 2025**

## Maintainability shown as effort duration

Maintainability is now displayed as estimated remediation effort (e.g. "2h 30m") in addition to issue counts, making it easier to compare projects and plan remediation work.

**November 21, 2025**

## Bitrise CI auto-detection

We now support automatic detection of build metadata from Bitrise. Uploading coverage from a Bitrise build only requires the path to the coverage data file.

```shell lines theme={"system"}
qlty coverage publish coverage.lcov
```

**October 28, 2025**

## Configuration typo warnings

The Qlty CLI now emits warnings when your `qlty.toml` contains unexpected attributes, helping you catch typos and outdated configuration syntax before they silently change your analysis.

**October 22, 2025**

## API rate limiting

Qlty API requests are now rate limited to protect service availability for all users. Clients that exceed the limit receive a `429 Too Many Requests` response with standard rate-limit headers, so your client can back off cleanly.

**October 16, 2025**

## Automatic path fixing for coverage

`qlty coverage publish` now automatically detects and corrects common path mismatches between coverage reports and the repository, including paths produced inside Docker containers and CI runners. This works in addition to the explicit `--add-prefix` and `--strip-prefix` options. See [Path Fixing](https://docs.qlty.sh/coverage/path-fixing.md) for details.

**October 9, 2025**

## Install-only mode

`qlty check` now supports an `--install-only` flag that installs the plugins required by your configuration without running them. Use it to warm caches in CI so the analysis step runs faster on every build.

**October 3, 2025**

## Onboarding flow

We've shipped an updated onboarding flow for new users and new Workspaces, walking through GitHub installation, Project selection, and coverage setup.

**September 15, 2025**

## Coding with AI agents

We've published a new guide on [coding with AI agents](https://docs.qlty.sh/cli/coding-with-ai-agents.md) that documents recommended patterns for using the Qlty CLI with Claude Code, Cursor, GitHub Copilot, OpenAI Codex, and other agents that can run shell commands.

**September 14, 2025**

## Applications

For teams that ship a single product across several repositories, Applications give you one view of code quality at the product level. Group related Projects together at the Workspace level and see aggregated maintainability, duplication, security, and coverage metrics across all of them.

Enable Applications from **Settings > Features**, then assign Projects from each Project's **Settings > General**. See the [Applications documentation](https://docs.qlty.sh/cloud/applications.md) for details.

## Churn view in Project Hotspots

The Project Hotspots page now includes a churn view that combines maintainability issues with file change frequency to surface the files most likely to benefit from refactoring.

**September 9, 2025**

## Self-service Workspace deletion

Workspace Owners can now delete their own Workspace directly from Workspace Settings, without needing to contact support.

**September 5, 2025**

## Improved Projects index

The Workspace Projects page now supports server-side sorting, a column picker, and shows the timestamp of the last build for each Project.

**September 4, 2025**

## Components

Track per-team or per-service code quality without splitting your repo. Qlty Cloud now supports Components, which let you group files inside a Project (for example, by service, package, or directory) and view maintainability metrics for each group independently.

Components are particularly useful for monorepos and modular codebases. Configure them from your Project's settings.

**August 29, 2025**

## Workspace Activation page

A new Activation page in Workspace Settings shows which Projects are activated, with sorting, filtering, and pagination — making it easier to manage Qlty across large organizations.

**August 27, 2025**

## ktlint plugin

We've added a plugin for [ktlint](https://github.com/pinterest/ktlint), an anti-bikeshedding Kotlin linter and formatter.

```bash lines theme={"system"}
qlty plugins enable ktlint
```

**August 21, 2025**

## Delegated billing

Delegated billing lets a single Workspace manage payment and subscription for one or more other Workspaces. This is useful for agencies, consultancies, and parent organizations that pay for multiple Workspaces.

**August 20, 2025**

## JaCoCo source path override

Java and Kotlin projects with non-standard source layouts can now point JaCoCo coverage uploads at the right directories by setting the `JACOCO_SOURCE_PATH` environment variable before running `qlty coverage publish`.

**August 18, 2025**

## Workspace Manager permissions

A new Workspace Manager role lets you delegate workspace-level administration to specific users without granting them GitHub Organization Owner permissions. See [User Permissions](https://docs.qlty.sh/cloud/permissions.md) for the full permissions matrix.

**August 11, 2025**

## GitHub Merge Queue support

The Qlty CLI now has initial support for GitHub Merge Queues. We also detect merge groups across any CI provider that listens to GitHub push events (#2320).

**August 5, 2025**

## Analysis Minutes progress bar

Workspace billing pages now show an Analysis Minutes progress bar and a usage breakdown table so you can see at a glance how your build minutes are being consumed.

**August 4, 2025**

## Workspace pausing

You can now pause a Workspace from its settings page. While paused, Qlty stops running analysis and coverage reporting — useful while a repository is dormant or when you need to temporarily halt billable usage without deleting the Workspace.

## Default coverage validation

`qlty coverage publish` now validates coverage reports by default, catching path mismatches and malformed reports before they corrupt your metrics. If you need to temporarily disable validation while fixing a report, use `--no-validate`:

```bash lines theme={"system"}
qlty coverage publish --no-validate coverage.lcov
```

See [Path Fixing](https://docs.qlty.sh/coverage/path-fixing.md) for details.

## zizmor plugin

We've added a plugin for [zizmor](https://github.com/woodruffw/zizmor), a security analyzer for GitHub Actions workflows.

```bash lines theme={"system"}
qlty plugins enable zizmor
```

**July 17, 2025**

## Coverprofile parser

The Qlty CLI now parses Go's native `cover.out` (Coverprofile) format. You can upload Go coverage data without converting to another format first.

```bash lines theme={"system"}
qlty coverage publish cover.out
```

## Faster debugging of plugin install failures

When a plugin fails to install, the Qlty CLI now surfaces the installation log directly in the main build log and points you to the full debug log on disk. No more guessing why a CI build broke during plugin setup.

**July 7, 2025**

## Project Hotspots

Qlty Cloud now includes a Hotspots page on every Project. Hotspots highlight the files most likely to need attention by combining maintainability, duplication, and (in later updates) churn data.

## Named API access tokens

API access tokens now have a name, description, and optional expiration date. You can manage your tokens from your user settings page. Existing tokens will continue to work — you can add metadata to them or rotate them at any time.

**July 4, 2025**

## Project Trends

Qlty Cloud now includes a Trends tab on every Project. The Trends view visualizes how key quality metrics — including maintainability, duplication, and code coverage — change over time on your default branch.

**June 25, 2025**

## Qlty API (beta)

Pull Qlty data into your own tools. The Qlty API is now in beta, with endpoints for listing and reading Projects and for reading analysis Issues for a Project. Authenticate with a personal access token from your user settings to query any Workspace you can access. See the [API Reference](https://docs.qlty.sh/api/introduction.md) for details.

## Coverage Diff commit status setting

A new workspace-level setting controls whether Qlty posts a separate **Coverage Diff** commit status to GitHub (in addition to the existing Coverage status). Toggle it from Workspace Settings if your branch protection rules don't expect this status.

**June 24, 2025**

## Git-free coverage publishing

You can now publish coverage from environments that don't have a Git working directory — for example, containers that only carry the test artifacts. Pass `--override-commit-time` to `qlty coverage publish` to skip Git detection.

**June 11, 2025**

## dotCover format support

The Qlty CLI now parses [dotCover](https://www.jetbrains.com/dotcover/) reports for .NET projects, in addition to the formats we already supported.

```bash lines theme={"system"}
qlty coverage publish coverage.dcvr
```

**June 2, 2025**

## SARIF output for `qlty smells`

`qlty smells` now supports the `--sarif` flag, joining `qlty check` in producing standardized [SARIF](https://sarifweb.azurewebsites.net/) output for integration with other tools.

```bash lines theme={"system"}
qlty smells --sarif
```

**May 5, 2025**

## Qlty Cloud Enterprise plan

We've added a new Enterprise plan for Qlty Cloud, tailored for organizations with advanced needs. This plan includes everything in our Pro plan, plus more analysis minutes and additional features to enhance your experience:

* Priority support with a SLA
* Named account manager available through a private Slack channel
* Consolidated billing for multiple GitHub organizations
* Payment via invoices (including ACH and wire transfer)
* Migration assistance
* Terms of Service customization

Learn more about the [Enterprise plan](https://qlty.sh/pricing) and how it can benefit your organization.

**May 2, 2025**

## Server-side coverage merging

We're proud to announce a long-requested feature: Server-side coverage merging!

In testing workflows which involve multiple test suites, parallelization, or multiple programming languages it is common to produce multiple code coveragate data files. Previously, we only offered client-side coverage merging which required that all of the coverage data was available on the same filesystem and sent to the server as a single upload.

In many scenarios, client-side merging was cumbersome and required uploading and downloading files from shared storage (like S3 or GitHub Actions artifacts). Also, visibility into the process was limited, resulting in a poor debugging experience if something went wrong.

The addition of server-side merging significantly simplifies the set up of code coverage reporting in complex CI workflows, and enabled full visibility into the process from Qlty Cloud. To ensure accurate reporting, we delay posting coverage reports to GitHub until all of the coverage data is received.

```yaml GitHub Action lines theme={"system"}
# Upload each coverage file separately
- uses: qltysh/qlty-action/coverage@v1
  with:
    oidc: true
    files: coverage/coverage1.lcov
    incomplete: true

- uses: qltysh/qlty-action/coverage@v1
  with:
  oidc: true
  files: coverage/coverage2.lcov
  incomplete: true

# Tell Qlty all parts have been uploaded

$ qlty coverage complete

```

```bash Qlty CLI lines theme={"system"}
# Upload each coverage file separately
qlty coverage publish --incomplete coverage/coverage1.lcov
qlty coverage publish --incomplete coverage/coverage2.lcov

# Tell Qlty all parts have been uploaded
qlty coverage complete
```

We support Learn more about [coverage merging](https://docs.qlty.sh/coverage/merging.md) in our documentation.

**May 1, 2025**

## Qlty Cloud is out of beta

We're excited to announce that we have completed our beta phase for Qlty Cloud and have advanced it to GA status!

Thank you to everyone who provided feedback and helped us improve the product during the beta period. We are proud to have made significant improvements based on your input, including:

* Server-side coverage merging
* OpenID Connect (OIDC) authentication for easier coverage setup
* Expanded support for programming languages like C# and Swift
* Additional plugins, bringing our total to 70+
* Significant performance improvements to the Qlty Cloud website
* Many bug fixes and improvements to the debugging experience

With Qlty Cloud now in GA, we'll be activating our billing system for all users by the end of the month. We offer a plan which is free for unlimited, private contributors and have paid plans with additional features and build minutes. Learn more on our [pricing page](https://qlty.sh/pricing).

We look forward to continuing to iterate Qlty rapidly to deliver code quality and coverage done right.

**April 30, 2025**

## StringsLint plugin

We've added a plugin for [StringsLint](https://github.com/dral3x/StringsLint) which is ensures that localized strings in a Swift project are complete and never unused.

StringsLint runs on macOS and targets files with the extensions `*.strings`, `*.stringsdict`, `*.swift`, `*.m`, `*.xib`, and `*.storyboard`. You can enable it using the Qlty CI:

```bash lines theme={"system"}
qlty plugins enable stringslint
```

> [!NOTE]
>
> StringsLint only runs on macOS and is not available on Qlty Cloud which runs on Linux.

## SwiftFormat plugin

We've added a plugin for [SwiftFormat](https://github.com/swiftlang/swift-format), the official auto-formatter for Swift. This auto-formatter targets Swift files, runs on macOS, and can be enabled using the Qlty CI:

```bash lines theme={"system"}
qlty plugins enable swiftformat
```

> [!NOTE]
>
> SwiftFormat only runs on macOS and is not available on Qlty Cloud which runs on Linux.

**April 28, 2025**

## Cloud authentication improvements

We've significantly improved the latency of most web pages by using a short-lived caching strategy for our GitHub authorization checks. Navigating around the website should feel faster. (The exception is the Dashboard, which we will be optimizing soon.)

Also, for organizations that use SAML on GitHub, we now detect when GitHub requires SAML re-authorization and use that information to render better error messages. Users accessing a GitHub organization with SAML enabled need to re-authorize occasionaly, and we now show a message with instructions on how to do that.

**April 27, 2025**

## Out-of-the-box linter configs

The Qlty CLI now provides out-of-the-box linter configurations for several popular linters. These linter configuration files are copied into your project when you run `qlty init` or `qlty plugins enable PLUGIN`.

This allows you to quickly set up your project with sensible defaults without needing to create a configuration file manually. Once the configuration files are in place, you can customize them to fit your project's needs.

**April 26, 2025**

## Swift maintainability analysis

Qlty now provides maintainability analysis for Swift. This includes duplication and complexity metrics as well as code smells. The maintainability analysis is available in the Qlty CLI and Qlty Cloud.

## ast-grep plugin

We've added a plugin for [ast-grep](https://ast-grep.github.io/) (sg), a fast polyglot structural search and linting tool supporting 20+ languages. ast-grep offers a pattern language to support writing your own [custom checks](https://docs.qlty.sh/custom-checks.md) or adopting checks provided by the ast-grep community.

```bash lines theme={"system"}
qlty plugins enable ast-grep
```

**April 25, 2025**

## Improved coverage uploader output

We've updated the output from `qlty coverage publish` to include more information to improve the setup an debugging experience.

```toml lines theme={"system"}
 SETTINGS

    cwd: /home/runner/work/qlty/qlty
    add-prefix: src/

 METADATA

    CI: GitHub
    Commit: c6dc5239a9e011e55ebdd598e35ce5700dc29741
    Branch: main
    Build ID: 14975425147:1

 COVERAGE FILES: 1

    Coverage File                 Format  Size
    remix/api-coverage/lcov.info  lcov    2.32 KiB

 COVERAGE DATA

    5 unique code file paths
    All code files in the coverage data were found on disk.

    Covered Lines:       57
    Uncovered Lines:     24
    Omitted Lines:      161

    Line Coverage:       70.37%

 EXPORTING...

    Exported: tmp/qlty-coverage/coverage.zip

 AUTHENTICATION

    Auth Method: OIDC
    Token: ***

 PREPARING TO UPLOAD...

    Upload ID: 0efcc860-ede8-4466-9170-038cee46ccd1

 UPLOADING...

    Uploaded 2.34 KiB in 0.28s!
    View report: https://qlty.sh/gh/qltysh/projects/qlty/settings/coverage/uploads/0efcc860-ede8-4466-9170-038cee46ccd1
```

**April 17, 2025**

## Package lockfiles

The Qlty CLI now uses package lockfiles (e.g. `package-lock.json`, `yarn.lock`, `Gemfile.lock`) when they are available and the `package_file` directive is specified in the `qlty.toml` configuration file. This ensures the exact same linter versions are used across all machines, including Qlty Cloud.

## V1 of Coverage GitHub Action

We've release v1.0.0 of our reusable GitHub Action for coverage uploading. We adhere to [semantic versioning](https://semver.org/) so going forward breaking changes will be represented with a bump in the major version.

To use the latest version on the v1 line, pin your CI workflows to `@v1` like this:

```yaml lines theme={"system"}
- uses: qltysh/qlty-action/coverage@v1
  with:
      oidc: true
      files: coverage/lcov.info
```

**April 15, 2025**

## BuildKite support

We now support automatic detection of build metadata from BuildKite. Therefore, uploading code coverage data from BuildKite only requires executing the Qlty CLI with the path to the coverage data file.

```shell lines theme={"system"}
qlty coverage publish coverage.lcov
```

**April 11, 2025**

## OpenID Connect (OIDC)

We now support OpenID Connect (OIDC) authentication for code coverage uploads from GitHub Actions.

OIDC allows us to authenticate the repository running a GitHub Actions workflow with a short-lived token. This enables coverage uploading without needing to manage a long-lived token, providing better security and easier coverage setup.

```yaml lines theme={"system"}
permissions:
  contents: read
  id-token: write # IMPORTANT

# ... Later in a workflow job: ...
- uses: qltysh/qlty-action/coverage@v1
  with:
    oidc: true
    files: coverage/lcov.info
```

**April 8, 2025**

## dockerfmt plugin

We've add a plugin for [dockerfmt](https://github.com/reteps/dockerfmt), a tool for automatically formatting Dockerfiles.

```bash lines theme={"system"}
qlty plugins enable dockerfmt
```

**April 4, 2025**

## Support Linux Arm64 Musl

The Qlty CLI now supports Linux systems using Arm64 architecture with Musl. We're now compiling binaries for these target systems with each release.

To install the Qlty CLI on an Arm64 Linux system using Musl, use our installer:

```shell lines theme={"system"}
curl https://qlty.sh | sh
```

**April 3, 2025**

## SARIF output from Qlty CLI

The Qlty CLI now supoprts [SARIF](https://sarifweb.azurewebsites.net/) output format. This is a standardized format for static analysis results, making it easier to integrate with other tools and platforms.

To use the SARIF output format, simply add the `--sarif` flag to your Qlty CLI command. For example:

```bash lines theme={"system"}
qlty check --sarif
```

**March 30, 2025**

## Code coverate tags (beta)

Qlty Cloud now offers support for Coverage Tags in beta. Coverage Tags are a powerful feature that allow you to group, upload, and report on coverage data with more granularity.

Coverage Tags are particularly useful to track coverage by suite independently. For example, you can track unit test coverage separately from integration test coverage. They can also be used in monorepos to make it easy to upload and report on coverage by service.

In addition to providing clear, independent reporting of coverage metrics, Coverage Tags also allow you to carry forward coverage data from previous runs. This means that you can maintain a complete picture of your code coverage over time, even if you only run a subset of all of your tests on each commit.

To use Coverage Tags, you can add the `--tag` flag to the `qlty coverage publish` command. For example:

```bash lines theme={"system"}
qlty coverage publish --tag unit coverage/unit.lcov
qlty coverage publish --tag integration coverage/integration.lcov
```

**March 27, 2025**

## php-cs-fixer plugin plugin

We've added support for [php-cs-fixer](https://cs.symfony.com/), a tool that fixes your PHP code to follow standards including the PHP coding standards as defined in the PSR-1, PSR-2, etc., or other community driven standards from organizations like Symfony.

```bash lines theme={"system"}
qlty plugins enable php-cs-fixer
```

**March 13, 2025**

## Checkstyle plugin

Qlty now supports [Checkstyle](https://checkstyle.sourceforge.io/), a tool that helps programmers write Java code that adheres to a coding standard.

```bash lines theme={"system"}
qlty plugins enable checkstyle
```

**March 1, 2025**

## Improved coverage comments

We've made significant improvements to the code coverage summary comments from Qlty Could. The new comments include more information about the coverage impact of your pull request, including diff coverage and a breakdown of coverage changes by file.

We've also added a "Help" section with definitions for the coverage metrics to help make it easier to interpret the results.

**February 25, 2025**

## Support for more SimpleCov formats

We have added support for additional SimpleCov formats to make it easier to get your code coverage data from SimpleCov ingested into Qlty Cloud. We now support the simplecov-json and simplecov-merged formats.

**February 21, 2025**

## Negated exclusion patterns

The Qlty CLI now supports negated exclusion patterns. Exclusion patterns are processed in order, matching the way that Git processes them. This means that if you have a negated pattern that matches a file, it will override any previous exclusion patterns that match the same file.

You can use negated exclusion patterns in your `qlty.toml` file by prefixing the pattern with an exclamation mark (`!`).

```toml lines theme={"system"}
exclude_patterns = [
  "**/ignores/**.sh",
  "!**/dont_ignore/**",
  "**/ignores/dont_ignore/ignore_this_one.sh"
]
```

**February 9, 2025**

## SempahoreCI support

We now support automatic detection of build metadata from SemaphoreCI. Therefore, uploading code coverage data from SemaphoreCI only requires executing the Qlty CLI with the path to the coverage data file.

```shell lines theme={"system"}
qlty coverage publish coverage.lcov
```

**February 7, 2025**

## Coverage example repositories

We now provide code coverage example repositories for many of the programming languages we support. These repositories are designed to help you get started with Qlty Cloud and provide a reference for how to set up code coverage reporting in your own projects.

You can find links to all of the example repositories in our [documentation](https://docs.qlty.sh/coverage/example-repositories.md).

**February 1, 2025**

## Docker images for Qlty CLI

We now build and publish Docker images for the Qlty CLI. This distribution format is an alternative to our native binaries and enables the use of the Qlty CLI on operating systems that are not natively supported.

The Docker images are available on [GitHub Container Registry](https://github.com/qltysh/qlty/pkgs/container/qlty).

```shell lines theme={"system"}
docker pull ghcr.io/qltysh/qlty:main
```

**January 30, 2025**

## Pull request coverage tab

Qlty Cloud has a new Coverage sub-tab on the Pull Request page. This tab provides a summary of the code coverage for the pull request, including a breakdown of coverage changes by file and their impact on your overall coverage. We also show the diff of the pull request with coverage annotations in the left gutter.

**January 20, 2025**

## Workspace-level coverage tokens

Qlty Cloud now offers Workspace-level coverage tokens in order to simplify the seet up of uploading code coverage data. This feature is particularly useful for organizations that have multiple repositories and want to use the same coverage token across all of them.

**January 16, 2025**

## Code coverage debugging information

We have significantly expanded the amount of debugging information available for code coverage uploads in the Qlty Cloud web app. Navigate the the "Code Covearge" section of Project Settings and you will be able to find a record of every code coverage upload, including the metadata and coverage metrics. We also provide a link to download the coverage information as a Zip file for easy inspeciton if something goes wrong.

**January 15, 2025**

## SOC 2 Type II certification

Qlty Software Inc. is proud to announce that we have achieved SOC 2 Type II certification. You can find our full announcement on our [blog](https://qlty.sh/blog/qlty-achieves-soc-2-type-ii-certification).

Additional information about our security and compliance program can be found in our [Trust Center](https://trust.qlty.sh/).

**January 7, 2025**

## C# maintainability analysis

Qlty now provides maintainability analysis for C#. This includes duplication and complexity metrics as well as code smells. The maintainability analysis is available in the Qlty CLI and Qlty Cloud.

**January 2, 2025**

## Qlty CLI is now Fair Source

The Qlty CLI is now released under a Fair Source license. This means that you can use the Qlty CLI for free including in commercial projects, as long as you are not using it to provide a competing service.

After a delay, the Qlty CLI code reverts to an OSI-approved Open Source license, also known as delayed Open Source publication (DOSP).

Read the full announcement on our [blog](https://qlty.sh/blog/qlty-cli-is-fair-source).


This documentation is built and hosted on [Mintlify](https://mintlify.com), a developer documentation platform.