Merge pull request #36 from dexoron/dev

Release v0.9.0

.github/workflows/ci.yml

@@ -5,10 +5,30 @@ on:
     branches:
       - master
       - main
+      - dev
+    paths:
+      - 'src/**'
+      - 'tests/**'
+      - 'Cargo.toml'
+      - 'Cargo.lock'
+      - '.github/workflows/ci.yml'
   pull_request:
+    paths:
+      - 'src/**'
+      - 'tests/**'
+      - 'Cargo.toml'
+      - 'Cargo.lock'
+      - '.github/workflows/ci.yml'
+
+env:
+  CARGO_TERM_COLOR: always
+  RUSTFLAGS: -Dwarnings
+  CARGO_INCREMENTAL: "0"
+  SCCACHE_GHA_ENABLED: "true"
 
 jobs:
   checks:
+    name: fmt / clippy / check
     runs-on: ubuntu-latest
     steps:
       - uses: actions/checkout@v4
@@ -18,11 +38,129 @@ jobs:
         with:
           components: rustfmt, clippy
 
+      - name: sccache
+        uses: mozilla-actions/sccache-action@v0.0.9
+
+      - uses: Swatinem/rust-cache@v2
+        with:
+          shared-key: dcr-ci
+          cache-all-crates: true
+
       - name: Format
         run: cargo fmt --all --check
 
-      - name: Lint
+      - name: Clippy (default features)
+        run: cargo clippy --all-targets -- -D warnings
+
+      - name: Clippy (all features)
         run: cargo clippy --all-targets --all-features -- -D warnings
 
-      - name: Check
+      - name: Check (all features)
         run: cargo check --all-targets --all-features
+
+  test:
+    name: tests (${{ matrix.os }})
+    needs: checks
+    strategy:
+      fail-fast: false
+      matrix:
+        os: [ubuntu-latest, macos-latest, windows-latest]
+    runs-on: ${{ matrix.os }}
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Setup Rust
+        uses: dtolnay/rust-toolchain@stable
+
+      - name: sccache
+        uses: mozilla-actions/sccache-action@v0.0.9
+
+      - uses: Swatinem/rust-cache@v2
+        with:
+          shared-key: dcr-ci
+          cache-all-crates: true
+          cache-on-failure: true
+
+      - name: Cache apt packages
+        if: runner.os == 'Linux'
+        uses: actions/cache@v4
+        with:
+          path: /var/cache/apt/archives
+          key: apt-${{ runner.os }}-${{ hashFiles('.github/workflows/ci.yml') }}
+          restore-keys: apt-${{ runner.os }}-
+
+      - name: Install Linux tools
+        if: runner.os == 'Linux'
+        run: |
+          sudo apt-get update
+          sudo apt-get install -y \
+            build-essential \
+            clang \
+            nasm \
+            clang-format \
+            clang-tidy \
+            git \
+            llvm
+
+      - name: Install macOS tools
+        if: runner.os == 'macOS'
+        run: |
+          brew install nasm llvm || true
+          echo "$(brew --prefix llvm)/bin" >> "$GITHUB_PATH"
+
+      - name: Install Windows tools
+        if: runner.os == 'Windows'
+        shell: pwsh
+        run: |
+          choco install nasm llvm -y
+          echo "C:\Program Files\NASM" | Out-File -FilePath $env:GITHUB_PATH -Encoding utf8 -Append
+          if (Test-Path "C:\Program Files\LLVM\bin") {
+            echo "C:\Program Files\LLVM\bin" | Out-File -FilePath $env:GITHUB_PATH -Encoding utf8 -Append
+          }
+
+      - name: Unit tests (binary crate)
+        run: cargo test --bins -- --nocapture
+
+      - name: Integration tests (default features)
+        run: cargo test --tests -- --nocapture
+
+      - name: Integration tests (archive feature)
+        if: runner.os != 'Windows'
+        run: cargo test --tests --features archive -- --nocapture
+
+      - name: sccache stats
+        if: always()
+        run: sccache --show-stats || true
+
+  test-archive-linux:
+    name: archive feature smoke
+    needs: checks
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Setup Rust
+        uses: dtolnay/rust-toolchain@stable
+
+      - name: sccache
+        uses: mozilla-actions/sccache-action@v0.0.9
+
+      - uses: Swatinem/rust-cache@v2
+        with:
+          shared-key: dcr-ci
+          cache-all-crates: true
+
+      - name: Install tools
+        run: |
+          sudo apt-get update
+          sudo apt-get install -y build-essential clang nasm llvm
+
+      - name: Build with archive
+        run: cargo build --features archive
+
+      - name: Flat-bin + unit suite with archive
+        run: cargo test --features archive --test cli_build --test cli_workspace --test cli_errors -- --nocapture
+
+      - name: sccache stats
+        if: always()
+        run: sccache --show-stats || true

.github/workflows/code-mirror.yml

@@ -0,0 +1,38 @@
+name: Mirror source code to GitVerse
+
+on:
+  push:
+    branches:
+      - '**'
+  workflow_dispatch:
+
+permissions:
+  contents: read
+
+concurrency:
+  group: code-mirror-${{ github.ref }}
+  cancel-in-progress: true
+
+jobs:
+  mirror:
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@v4
+        with:
+          fetch-depth: 0
+
+      - name: Mirror all branches
+        env:
+          GITVERSE_PAT: ${{ secrets.GITVERSE_PAT }}
+          GITVERSE_ORG: ${{ vars.GITVERSE_ORG || 'dcr_labs' }}
+          GITVERSE_REPO: ${{ vars.GITVERSE_REPO || 'dcr' }}
+        run: |
+          set -euo pipefail
+          test -n "$GITVERSE_PAT" || { echo 'GITVERSE_PAT is not configured' >&2; exit 1; }
+          remote="https://oauth2:${GITVERSE_PAT}@gitverse.ru/${GITVERSE_ORG}/${GITVERSE_REPO}.git"
+          git remote add gitverse "$remote"
+          # Use a private ref namespace: Git will not overwrite the checked-out
+          # branch, and broken legacy submodule metadata is not traversed.
+          git fetch --no-recurse-submodules origin '+refs/heads/*:refs/mirror/*'
+          git push --prune --force gitverse 'refs/mirror/*:refs/heads/*'

.github/workflows/release-mirror.yml

@@ -0,0 +1,290 @@
+name: Mirror releases to GitVerse, SourceCraft, and GitLab
+
+on:
+  workflow_run:
+    workflows:
+      - Release
+    types:
+      - completed
+  workflow_dispatch:
+    inputs:
+      tag:
+        description: Git tag of the GitHub release to mirror (for example v0.7.1)
+        required: true
+        type: string
+
+permissions:
+  contents: read
+
+jobs:
+  setup:
+    runs-on: ubuntu-latest
+    outputs:
+      tag: ${{ steps.release.outputs.tag }}
+      found: ${{ steps.release.outputs.found }}
+    steps:
+      - name: Resolve release tag
+        id: release
+        env:
+          GH_TOKEN: ${{ github.token }}
+          MANUAL_TAG: ${{ inputs.tag }}
+          WORKFLOW_HEAD_BRANCH: ${{ github.event.workflow_run.head_branch }}
+          WORKFLOW_HEAD_SHA: ${{ github.event.workflow_run.head_sha }}
+        run: |
+          set -euo pipefail
+          tag="$MANUAL_TAG"
+          if [ -z "$tag" ] && [[ "$WORKFLOW_HEAD_BRANCH" == v* ]]; then
+            tag="$WORKFLOW_HEAD_BRANCH"
+          fi
+          if [ -z "$tag" ] && [ -n "$WORKFLOW_HEAD_SHA" ]; then
+            releases=$(curl -fsSL -H "Authorization: Bearer $GH_TOKEN" \
+              -H 'Accept: application/vnd.github+json' \
+              "https://api.github.com/repos/${GITHUB_REPOSITORY}/releases?per_page=100")
+            while IFS= read -r candidate; do
+              ref=$(curl -fsSL -H "Authorization: Bearer $GH_TOKEN" \
+                -H 'Accept: application/vnd.github+json' \
+                "https://api.github.com/repos/${GITHUB_REPOSITORY}/git/ref/tags/${candidate}")
+              sha=$(jq -r '.object.sha' <<< "$ref")
+              if [ "$(jq -r '.object.type' <<< "$ref")" = tag ]; then
+                sha=$(curl -fsSL -H "Authorization: Bearer $GH_TOKEN" \
+                  -H 'Accept: application/vnd.github+json' \
+                  "https://api.github.com/repos/${GITHUB_REPOSITORY}/git/tags/${sha}" | jq -r '.object.sha')
+              fi
+              if [ "$sha" = "$WORKFLOW_HEAD_SHA" ]; then
+                tag="$candidate"
+                break
+              fi
+            done < <(jq -r '.[].tag_name' <<< "$releases")
+          fi
+          if [ -z "$tag" ] || [[ "$tag" != v* ]]; then
+            echo 'No release tag was found; release.yml may have failed before creating a GitHub release.'
+            echo 'found=false' >> "$GITHUB_OUTPUT"
+            exit 0
+          fi
+          echo "tag=$tag" >> "$GITHUB_OUTPUT"
+          echo 'found=true' >> "$GITHUB_OUTPUT"
+
+      - name: Download GitHub release metadata and assets
+        if: steps.release.outputs.found == 'true'
+        env:
+          GH_TOKEN: ${{ github.token }}
+          TAG: ${{ steps.release.outputs.tag }}
+        run: |
+          set -euo pipefail
+          mkdir -p assets
+          curl -fsSL -H "Authorization: Bearer $GH_TOKEN" \
+            -H 'Accept: application/vnd.github+json' \
+            "https://api.github.com/repos/${GITHUB_REPOSITORY}/releases/tags/${TAG}" > release.json
+          jq -e '.tag_name == $tag' --arg tag "$TAG" release.json >/dev/null
+
+          total=$(jq '.assets | length' release.json)
+          downloaded=0
+          failed=0
+          while IFS=$'	' read -r name url; do
+            if curl -fsSL -L -H "Authorization: Bearer $GH_TOKEN" \
+              -H 'Accept: application/octet-stream' -o "assets/$name" "$url"; then
+              downloaded=$((downloaded+1))
+            else
+              echo "::warning::Failed to download asset: $name"
+              failed=$((failed+1))
+            fi
+          done < <(jq -r '.assets[] | [.name, .browser_download_url] | @tsv' release.json)
+
+          echo "Downloaded ${downloaded}/${total} assets (${failed} failed)"
+          [ "$failed" -eq 0 ] || { echo 'Not all release assets were downloaded.' >&2; exit 1; }
+
+      - name: Upload release metadata artifact
+        if: steps.release.outputs.found == 'true'
+        uses: actions/upload-artifact@v4
+        with:
+          name: release-mirror-data
+          path: |
+            release.json
+            assets/*
+          if-no-files-found: error
+
+  mirror-gitverse:
+    needs: setup
+    if: needs.setup.outputs.found == 'true'
+    runs-on: ubuntu-latest
+    steps:
+      - name: Download release metadata
+        uses: actions/download-artifact@v4
+        with:
+          name: release-mirror-data
+
+      - name: Sync tag and release to GitVerse
+        env:
+          GITVERSE_PAT: ${{ secrets.GITVERSE_PAT }}
+          GITVERSE_ORG: ${{ vars.GITVERSE_ORG || 'dcr_labs' }}
+          GITVERSE_REPO: ${{ vars.GITVERSE_REPO || 'dcr' }}
+          TAG: ${{ needs.setup.outputs.tag }}
+        run: |
+          set -euo pipefail
+          test -n "$GITVERSE_PAT" || { echo 'GITVERSE_PAT is not configured' >&2; exit 1; }
+          project="${GITVERSE_ORG}%2F${GITVERSE_REPO}"
+          remote="https://oauth2:${GITVERSE_PAT}@gitverse.ru/${GITVERSE_ORG}/${GITVERSE_REPO}.git"
+          git clone --mirror "https://github.com/${GITHUB_REPOSITORY}.git" mirror.git
+          git -C mirror.git remote add gitverse "$remote"
+          git -C mirror.git push gitverse "refs/tags/${TAG}:refs/tags/${TAG}"
+
+          title=$(jq -r '.name // .tag_name' release.json)
+          notes=$(jq -r '.body // ""' release.json)
+          payload=$(jq -n --arg tag "$TAG" --arg title "$title" --arg notes "$notes" \
+            '{name:$title, tag_name:$tag, description:$notes, ref:$tag}')
+
+          http=$(curl -sS -o gitverse-release.json -w '%{http_code}' \
+            -H "PRIVATE-TOKEN: $GITVERSE_PAT" \
+            "https://gitverse.ru/api/v4/projects/${project}/releases/${TAG}" || true)
+          if [ "$http" = '200' ]; then
+            echo "GitVerse release ${TAG} already exists; skipping create."
+          else
+            curl -fsSL -X POST -H "PRIVATE-TOKEN: $GITVERSE_PAT" \
+              -H 'Content-Type: application/json' --data "$payload" \
+              "https://gitverse.ru/api/v4/projects/${project}/releases" || \
+            curl -fsSL -X PUT -H "PRIVATE-TOKEN: $GITVERSE_PAT" \
+              -H 'Content-Type: application/json' --data "$payload" \
+              "https://gitverse.ru/api/v4/projects/${project}/releases/${TAG}"
+          fi
+
+          uploaded=0; failed=0
+          for file in assets/*; do
+            [ -f "$file" ] || continue
+            name=$(basename "$file")
+            
+            upload_response=$(curl -sS -w "\n%{http_code}" -X POST -H "PRIVATE-TOKEN: $GITVERSE_PAT" \
+              -F "file=@$file" "https://gitverse.ru/api/v4/projects/${project}/uploads")
+            http_code=$(echo "$upload_response" | tail -n1)
+            body=$(echo "$upload_response" | sed '$d')
+            
+            if [ "$http_code" != "201" ] && [ "$http_code" != "200" ]; then
+              echo "::warning::GitVerse: failed to upload $name (HTTP $http_code)"
+              failed=$((failed+1))
+              continue
+            fi
+            
+            url=$(jq -r '.url // .file_path' <<< "$body" 2>/dev/null || echo "")
+            if [ -z "$url" ]; then
+              echo "::warning::GitVerse: failed to parse upload response for $name"
+              failed=$((failed+1))
+              continue
+            fi
+            
+            link=$(jq -n --arg name "$name" --arg url "$url" '{name:$name,url:$url}')
+            link_response=$(curl -sS -w "\n%{http_code}" -X POST -H "PRIVATE-TOKEN: $GITVERSE_PAT" \
+              -H 'Content-Type: application/json' --data "$link" \
+              "https://gitverse.ru/api/v4/projects/${project}/releases/${TAG}/assets/links")
+            link_http=$(echo "$link_response" | tail -n1)
+            
+            if [ "$link_http" = "201" ] || [ "$link_http" = "200" ] || [ "$link_http" = "409" ]; then
+              uploaded=$((uploaded+1))
+            else
+              echo "::warning::GitVerse: failed to attach asset $name (HTTP $link_http)"
+              failed=$((failed+1))
+            fi
+          done
+          echo "GitVerse: uploaded ${uploaded}, failed ${failed}"
+          [ "$failed" -eq 0 ] || exit 1
+
+  mirror-sourcecraft:
+    needs: setup
+    if: needs.setup.outputs.found == 'true'
+    runs-on: ubuntu-latest
+    steps:
+      - name: Download release metadata
+        uses: actions/download-artifact@v4
+        with:
+          name: release-mirror-data
+
+      - name: Sync tag and release to SourceCraft
+        env:
+          SOURCECRAFT_PAT: ${{ secrets.SOURCECRAFT_PAT }}
+          SOURCECRAFT_ORG: ${{ vars.SOURCECRAFT_ORG || 'dexoron-dev' }}
+          SOURCECRAFT_REPO: ${{ vars.SOURCECRAFT_REPO || 'dcr' }}
+          TAG: ${{ needs.setup.outputs.tag }}
+        run: |
+          set -euo pipefail
+          test -n "$SOURCECRAFT_PAT" || { echo 'SOURCECRAFT_PAT is not configured' >&2; exit 1; }
+          remote="https://anyname:${SOURCECRAFT_PAT}@git.sourcecraft.dev/${SOURCECRAFT_ORG}/${SOURCECRAFT_REPO}.git"
+          git clone "$remote" sourcecraft
+          git -C sourcecraft remote add github "https://github.com/${GITHUB_REPOSITORY}.git"
+          git -C sourcecraft fetch github "refs/tags/${TAG}:refs/tags/${TAG}"
+          git -C sourcecraft push origin "refs/tags/${TAG}"
+
+          title=$(jq -r '.name // .tag_name' release.json)
+          notes=$(jq -r '.body // ""' release.json)
+          payload=$(jq -n --arg tag "$TAG" --arg title "$title" --arg notes "$notes" \
+            '{tag:$tag,title:$title,release_notes:$notes,publish:true}')
+          base="https://api.sourcecraft.tech/repos/${SOURCECRAFT_ORG}/${SOURCECRAFT_REPO}"
+
+          http=$(curl -sS -o /dev/null -w '%{http_code}' \
+            -H "Authorization: Bearer $SOURCECRAFT_PAT" "${base}/releases/tag/${TAG}" || true)
+          if [ "$http" != '200' ]; then
+            curl -fsSL -X POST -H "Authorization: Bearer $SOURCECRAFT_PAT" \
+              -H 'Content-Type: application/json' --data "$payload" "${base}/releases" || \
+            curl -fsSL -X PUT -H "Authorization: Bearer $SOURCECRAFT_PAT" \
+              -H 'Content-Type: application/json' --data "$payload" "${base}/releases/${TAG}" || \
+            echo 'SourceCraft release already exists; continuing with assets.'
+          else
+            echo "SourceCraft release ${TAG} already exists; continuing with assets."
+          fi
+
+          uploaded=0; failed=0
+          for file in assets/*; do
+            [ -f "$file" ] || continue
+            name=$(basename "$file")
+            
+            upload_response=$(curl -sS -w "\n%{http_code}" -X POST -H "Authorization: Bearer $SOURCECRAFT_PAT" \
+              -F "file=@$file" \
+              "${base}/releases/tag/${TAG}/assets")
+            http_code=$(echo "$upload_response" | tail -n1)
+            
+            if [ "$http_code" = "201" ] || [ "$http_code" = "200" ]; then
+              uploaded=$((uploaded+1))
+            elif [ "$http_code" = "409" ]; then
+              uploaded=$((uploaded+1))
+            else
+              echo "::warning::SourceCraft: failed to attach asset $name (HTTP $http_code)"
+              failed=$((failed+1))
+            fi
+          done
+          echo "SourceCraft: uploaded ${uploaded}, failed ${failed}"
+          [ "$failed" -eq 0 ] || exit 1
+
+  mirror-gitlab:
+    needs: setup
+    if: needs.setup.outputs.found == 'true'
+    runs-on: ubuntu-latest
+    continue-on-error: true
+    steps:
+      - name: Download release metadata
+        uses: actions/download-artifact@v4
+        with:
+          name: release-mirror-data
+
+      - name: Sync release to GitLab
+        env:
+          GITLAB_PAT: ${{ secrets.GITLAB_PAT }}
+          GITLAB_PROJECT: ${{ vars.GITLAB_PROJECT || 'dexoron-dev/dcr-tool/dcr' }}
+          TAG: ${{ needs.setup.outputs.tag }}
+        run: |
+          set -euo pipefail
+          test -n "$GITLAB_PAT" || { echo 'GITLAB_PAT is not configured' >&2; exit 0; }
+
+          project_id="${GITLAB_PROJECT//\//%2F}"
+          api="https://gitlab.com/api/v4/projects/${project_id}"
+          title=$(jq -r '.name // .tag_name' release.json)
+          notes=$(jq -r '.body // ""' release.json)
+          payload=$(jq -n --arg tag "$TAG" --arg title "$title" --arg notes "$notes" \
+            '{tag_name:$tag, name:$title, description:$notes}')
+
+          http=$(curl -sS -o /dev/null -w '%{http_code}' \
+            -H "PRIVATE-TOKEN: $GITLAB_PAT" "${api}/releases/${TAG}" || true)
+          if [ "$http" = '200' ]; then
+            echo "GitLab release ${TAG} already exists; skipping"
+            exit 0
+          fi
+
+          echo "Creating release on GitLab..."
+          curl -fsSL -X POST -H "PRIVATE-TOKEN: $GITLAB_PAT" \
+            -H 'Content-Type: application/json' --data "$payload" "${api}/releases" || true

.github/workflows/release.yml

@@ -21,6 +21,10 @@ on:
         description: "Update AUR packages (dcr & dcr-bin)"
         type: boolean
         default: false 
+      run_aur_dev:
+        description: "Update Dev AUR packages (dcr-dev, dcr-dev-bin)"
+        type: boolean
+        default: false
       run_bsd:
         description: "Build BSD"
         type: boolean
@@ -37,14 +41,14 @@ on:
         description: "Publish to crates.io"
         type: boolean
         default: false
-      run_snap:
-        description: "Publish to Snap Store (dcrup)"
-        type: boolean
-        default: false
       run_brew:
         description: "Update Homebrew tap"
         type: boolean
         default: false
+      run_s3:
+        description: "Mirror Release to Yandex Object Storage (S3)"
+        type: boolean
+        default: false
 
 permissions:
   contents: write
@@ -56,6 +60,7 @@ jobs:
     outputs:
       tag: ${{ steps.tag.outputs.value }}
       version: ${{ steps.tag.outputs.version }}
+      clean_version: ${{ steps.tag.outputs.clean_version }}
       prerelease: ${{ steps.tag.outputs.prerelease }}
     steps:
       - name: Resolve tag
@@ -67,33 +72,53 @@ jobs:
             TAG="${GITHUB_REF_NAME}"
           fi
           VERSION="${TAG#v}"
+          CLEAN_VERSION="${VERSION%-dev}"
           [[ "$TAG" == *"-"* ]] && PRERELEASE="true" || PRERELEASE="false"
           echo "value=${TAG}"             >> "$GITHUB_OUTPUT"
           echo "version=${VERSION}"       >> "$GITHUB_OUTPUT"
+          echo "clean_version=${CLEAN_VERSION}" >> "$GITHUB_OUTPUT"
           echo "prerelease=${PRERELEASE}" >> "$GITHUB_OUTPUT"
 
   # ── Release Notes ──────────────────────────────────────────────────────────
   notes:
     needs: setup
     runs-on: ubuntu-latest
+    outputs:
+      release_name: ${{ steps.extract.outputs.release_name }}
     steps:
       - uses: actions/checkout@v4
         with:
           ref: ${{ needs.setup.outputs.tag }}
 
       - name: Prepare Release Notes
+        id: extract
         shell: bash
         run: |
           set -euo pipefail
           tag="${{ needs.setup.outputs.version }}"
           notes_file=".github/release-notes.md"
-          if grep -q "^## \\[${tag}\\]" CHANGELOG.md; then
+          # Strip -dev suffix to match base version in CHANGELOG
-            awk -v ver="$tag" '
+          changelog_tag="${tag%-dev}"
+          if grep -q "^## \\[${changelog_tag}\\]" CHANGELOG.md; then
+            # Extract release name from header: ## [0.7.1] - 2026-06-02 "Title"
+            release_name=$(awk -v search_ver="$changelog_tag" -v display_ver="$tag" '
+              $0 ~ "^## \\[" search_ver "\\]" {
+                match($0, /"([^"]+)"/, arr)
+                if (arr[1] != "") {
+                  print "v" display_ver " - " arr[1]
+                } else {
+                  print "v" display_ver
+                }
+              }
+            ' CHANGELOG.md)
+            echo "release_name=${release_name}" >> "$GITHUB_OUTPUT"
+            awk -v ver="$changelog_tag" '
               $0 ~ "^## \\[" ver "\\]" {found=1; next}
               found && $0 ~ "^## \\[" {exit}
               found {print}
             ' CHANGELOG.md | sed -e '${/^$/d;}' > "$notes_file"
           else
+            echo "release_name=v${tag}" >> "$GITHUB_OUTPUT"
             echo "No CHANGELOG section for $tag." > "$notes_file"
             git log -1 --pretty=format:"%s%n%n%b" >> "$notes_file"
           fi
@@ -119,6 +144,37 @@ jobs:
         uses: softprops/action-gh-release@v2
         with:
           tag_name: ${{ needs.setup.outputs.tag }}
+          name: ${{ needs.notes.outputs.release_name }}
+          body_path: .github/release-notes.md
+          prerelease: ${{ needs.setup.outputs.prerelease == 'true' }}
+
+  # ── Man Pages Archive ──────────────────────────────────────────────────────
+  man-pages:
+    if: ${{ github.event_name == 'push' || github.event.inputs.run_linux == 'true' }}
+    needs: [setup, notes, create-release]
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          ref: ${{ needs.setup.outputs.tag }}
+
+      - name: Download Release Notes
+        uses: actions/download-artifact@v4
+        with:
+          name: release-notes
+          path: .github
+
+      - name: Create Man Pages Archive
+        run: |
+          tar czf "dcr-man-pages-${{ needs.setup.outputs.version }}.tar.gz" \
+            --transform 's/^man\/man1\//usr\/share\/man\/man1\//' \
+            man/man1/*.1
+
+      - name: Upload Man Pages to Release
+        uses: softprops/action-gh-release@v2
+        with:
+          tag_name: ${{ needs.setup.outputs.tag }}
+          files: dcr-man-pages-${{ needs.setup.outputs.version }}.tar.gz
           body_path: .github/release-notes.md
           prerelease: ${{ needs.setup.outputs.prerelease == 'true' }}
 
@@ -135,6 +191,12 @@ jobs:
           - target: aarch64-unknown-linux-gnu
           - target: x86_64-unknown-linux-musl
           - target: aarch64-unknown-linux-musl
+          - target: i686-unknown-linux-gnu
+          - target: i686-unknown-linux-musl
+          - target: armv7-unknown-linux-gnueabihf
+          - target: armv7-unknown-linux-musleabihf
+          - target: riscv64gc-unknown-linux-gnu
+          - target: riscv64gc-unknown-linux-musl
     steps:
       - uses: actions/checkout@v4
         with:
@@ -165,9 +227,9 @@ jobs:
       - name: Build
         run: |
           if [ "${{ matrix.target }}" != "x86_64-unknown-linux-gnu" ]; then
-            cargo zigbuild --release --target ${{ matrix.target }}
+            cargo zigbuild --release --features archive --target ${{ matrix.target }}
           else
-            cargo build --release --target ${{ matrix.target }}
+            cargo build --release --features archive --target ${{ matrix.target }}
           fi
 
       - name: Prepare Artifact
@@ -192,49 +254,82 @@ jobs:
     strategy:
       fail-fast: false
       matrix:
-        include:
+        package_type: [deb, rpm, arch, snap]
-          - package_type: deb
+        target: [x86_64-unknown-linux-gnu, aarch64-unknown-linux-gnu, i686-unknown-linux-gnu, armv7-unknown-linux-gnueabihf, riscv64gc-unknown-linux-gnu]
-            artifact_name: debian-package
+        exclude:
-          - package_type: rpm
-            artifact_name: rpm-package
           - package_type: arch
-            artifact_name: arch-package
+            target: aarch64-unknown-linux-gnu
+          - package_type: arch
+            target: i686-unknown-linux-gnu
+          - package_type: arch
+            target: armv7-unknown-linux-gnueabihf
+          - package_type: arch
+            target: riscv64gc-unknown-linux-gnu
           - package_type: snap
-            artifact_name: snap-package
+            target: aarch64-unknown-linux-gnu
+          - package_type: snap
+            target: i686-unknown-linux-gnu
+          - package_type: snap
+            target: armv7-unknown-linux-gnueabihf
+          - package_type: snap
+            target: riscv64gc-unknown-linux-gnu
     steps:
       - uses: actions/checkout@v4
         with:
           ref: ${{ needs.setup.outputs.tag }}
 
-      - name: Setup Rust (For non-container builds)
+      - name: Install cargo-zigbuild
+        if: matrix.package_type == 'deb' || matrix.package_type == 'rpm'
+        run: |
+          pip install cargo-zigbuild
+          echo "$HOME/.local/bin" >> $GITHUB_PATH
+
+      - name: Setup Zig
+        if: (matrix.package_type == 'deb' || matrix.package_type == 'rpm') && matrix.target != 'x86_64-unknown-linux-gnu'
+        uses: mlugg/setup-zig@v1
+        with:
+          version: 0.13.0
+
+      - name: Setup Rust
         if: matrix.package_type != 'arch'
         uses: dtolnay/rust-toolchain@stable
+        with:
+          targets: ${{ matrix.target }}
 
       # ── DEB Build ──
       - name: Build Debian Package
         if: matrix.package_type == 'deb'
         run: |
           cargo install cargo-deb
-          cargo build --release
+          if [ "${{ matrix.target }}" != "x86_64-unknown-linux-gnu" ]; then
-          cargo deb --no-build
+            cargo zigbuild --release --features archive --target ${{ matrix.target }}
-          mkdir -p dist-packages && cp target/debian/*.deb dist-packages/
+          else
+            cargo build --release --features archive --target ${{ matrix.target }}
+          fi
+          cargo deb --no-build --target ${{ matrix.target }}
+          mkdir -p dist-packages && cp target/${{ matrix.target }}/debian/*.deb dist-packages/
 
       # ── RPM Build ──
       - name: Build RPM Package
         if: matrix.package_type == 'rpm'
         run: |
           cargo install cargo-generate-rpm
-          cargo build --release
+          if [ "${{ matrix.target }}" != "x86_64-unknown-linux-gnu" ]; then
-          cargo generate-rpm
+            cargo zigbuild --release --features archive --target ${{ matrix.target }}
-          mkdir -p dist-packages && cp target/generate-rpm/*.rpm dist-packages/
+          else
+            cargo build --release --features archive --target ${{ matrix.target }}
+          fi
+          cargo generate-rpm --target ${{ matrix.target }}
+          mkdir -p dist-packages && cp target/${{ matrix.target }}/generate-rpm/*.rpm dist-packages/
 
       # ── Snap Build ──
       - name: Build Snap Package
         if: matrix.package_type == 'snap'
         run: |
-          cargo build --release
+          cargo build --release --features archive
           mkdir -p packaging/snap/dist/bin
           cp target/release/dcr packaging/snap/dist/bin/
+          cp -r man packaging/snap/dist/man
 
       - name: Snapcraft Build Action
         if: matrix.package_type == 'snap'
@@ -271,12 +366,17 @@ jobs:
           sha256sums=('${SHA256}')
           build() {
             cd "\$srcdir/\$pkgname-${PKGVER_ORIG}"
-            cargo build --release --locked
+            unset CFLAGS CXXFLAGS LDFLAGS
+            export RUSTFLAGS="-C linker=cc"
+            cargo build --release --locked --features archive
           }
           package() {
-            cd "\$srcdir/\$pkgname-${PKGVER_ORIG}"
+            cd "\$srcdir/dcr-${PKGVER_ORIG}"
             install -Dm755 "target/release/dcr" "\$pkgdir/usr/bin/dcr"
             install -Dm644 LICENSE "\$pkgdir/usr/share/licenses/\$pkgname/LICENSE"
+            for manpage in man/man1/*.1; do
+              install -Dm644 "\$manpage" "\$pkgdir/usr/share/man/man1/\$(basename "\$manpage")"
+            done
           }
           PKG
           docker run --rm \
@@ -296,7 +396,7 @@ jobs:
       - name: Upload Package Artifact
         uses: actions/upload-artifact@v4
         with:
-          name: ${{ matrix.artifact_name }}
+          name: ${{ matrix.package_type }}-package-${{ matrix.target }}
           path: dist-packages/*
           if-no-files-found: ignore
 
@@ -321,10 +421,10 @@ jobs:
         with:
           tag_name: ${{ needs.setup.outputs.tag }}
           files: |
-            collected-packages/debian-package/*
+            collected-packages/deb-package-*/*
-            collected-packages/rpm-package/*
+            collected-packages/rpm-package-*/*
-            collected-packages/arch-package/*
+            collected-packages/arch-package-*/*
-            collected-packages/snap-package/*
+            collected-packages/snap-package-*/*
           body_path: .github/release-notes.md
           prerelease: ${{ needs.setup.outputs.prerelease == 'true' }}
 
@@ -358,7 +458,7 @@ jobs:
           targets: ${{ matrix.target }}
 
       - name: Build
-        run: cargo build --release --target ${{ matrix.target }}
+        run: cargo build --release --features archive --target ${{ matrix.target }}
 
       - name: Prepare Artifact
         run: |
@@ -403,7 +503,7 @@ jobs:
           run: |
             export PATH="/usr/local/bin:/usr/local/sbin:$PATH"
             pkg install -y rust perl5 gmake
-            cargo build --release
+            cargo build --release --features archive
 
       - name: Prepare FreeBSD Artifact
         if: matrix.system == 'freebsd'
@@ -421,7 +521,7 @@ jobs:
           run: |
             export PATH="/usr/local/bin:$PATH"
             pkg_add rust perl gmake
-            cargo build --release
+            cargo build --release --features archive
 
       - name: Prepare OpenBSD Artifact
         if: matrix.system == 'openbsd'
@@ -441,7 +541,7 @@ jobs:
             mkdir -p /tmp/bin
             ln -sf /usr/pkg/bin/gmake /tmp/bin/make
             export PATH="/tmp/bin:/usr/pkg/bin:/usr/pkg/sbin:$PATH"
-            cargo build --release
+            cargo build --release --features archive
 
       - name: Prepare NetBSD Artifact
         if: matrix.system == 'netbsd'
@@ -450,8 +550,6 @@ jobs:
           cp target/release/dcr "$ASSET"
           echo "BSD_ASSET=${ASSET}" >> "$GITHUB_ENV"
 
-
-
       # --- UPLOAD TARGET ---
       - name: Upload BSD Asset to Release
         uses: softprops/action-gh-release@v2
@@ -472,6 +570,7 @@ jobs:
         include:
           - target: x86_64-pc-windows-msvc
           - target: aarch64-pc-windows-msvc
+          - target: i686-pc-windows-msvc
           - target: x86_64-pc-windows-gnu
     steps:
       - uses: actions/checkout@v4
@@ -490,7 +589,7 @@ jobs:
           targets: ${{ matrix.target }}
 
       - name: Build
-        run: cargo build --release --target ${{ matrix.target }}
+        run: cargo build --release --features archive --target ${{ matrix.target }}
 
       - name: Prepare Artifact
         shell: pwsh
@@ -552,21 +651,23 @@ jobs:
             'gcc: build C/C++ projects with GCC'
             'clang: build C/C++ projects with Clang'
           )
-          source=("\$pkgname-\$pkgver.tar.gz::\${SRC_URL}")
+          source=("\$pkgname-\$pkgver.tar.gz::${SRC_URL}")
           sha256sums=('${SHA256}')
 
           build() {
             cd "\$srcdir/\$pkgname-${PKGVER_ORIG}"
-            export CARGO_PROFILE_RELEASE_LTO=false
+            unset CFLAGS CXXFLAGS LDFLAGS
-            export RUSTFLAGS="\${RUSTFLAGS:-}"
+            export RUSTFLAGS="-C linker=cc"
-            export RUSTFLAGS="\${RUSTFLAGS/-C link-arg=-fuse-ld=lld/}"
+            cargo build --release --locked --features archive
-            cargo build --release --locked
           }
 
           package() {
             cd "\$srcdir/\$pkgname-${PKGVER_ORIG}"
             install -Dm755 "target/release/dcr" "\$pkgdir/usr/bin/dcr"
             install -Dm644 LICENSE "\$pkgdir/usr/share/licenses/\$pkgname/LICENSE"
+            for manpage in man/man1/*.1; do
+              install -Dm644 "\$manpage" "\$pkgdir/usr/share/man/man1/\$(basename "\$manpage")"
+            done
           }
           PKG
 
@@ -603,22 +704,31 @@ jobs:
           ssh-keyscan aur.archlinux.org >> ~/.ssh/known_hosts
 
           export GIT_SSH_COMMAND='ssh -i ~/.ssh/aur -o IdentitiesOnly=yes'
-          git clone "ssh://aur@aur.archlinux.org/${AUR_PACKAGE}.git" aur-repo
+          
-          cp packages/aur/dcr/PKGBUILD aur-repo/PKGBUILD
+          mkdir -p aur-repo
-          cp packages/aur/dcr/.SRCINFO aur-repo/.SRCINFO
-
           cd aur-repo
+          git init
+          git remote add origin "ssh://aur@aur.archlinux.org/${AUR_PACKAGE}.git"
+          
+          git fetch origin master || true
+          git checkout master || git checkout -b master
+          
+          cp ../packages/aur/dcr/PKGBUILD .
+          cp ../packages/aur/dcr/.SRCINFO .
+
           git config user.name "github-actions[bot]"
           git config user.email "github-actions[bot]@users.noreply.github.com"
 
-          if git diff --quiet; then
+          if git rev-parse --verify HEAD >/dev/null 2>&1; then
-            echo "No AUR changes"
+            if git diff --quiet; then
-            exit 0
+              echo "No AUR changes"
+              exit 0
+            fi
           fi
 
           git add PKGBUILD .SRCINFO
           git commit -m "dcr ${{ needs.setup.outputs.version }}"
-          git push
+          git push -u origin master
 
   # ── Arch User Repository (dcr-bin) ────────────────────────────────
   publish-aur-bin:
@@ -635,10 +745,22 @@ jobs:
         shell: bash
         run: |
           set -euo pipefail
-          BIN_URL="https://github.com/dexoron/dcr/releases/download/${{ needs.setup.outputs.tag }}/dcr-x86_64-unknown-linux-musl-${{ needs.setup.outputs.version }}"
+          TAG="${{ needs.setup.outputs.tag }}"
-          SHA256="$(curl -fsSL "$BIN_URL" | sha256sum | awk '{print $1}')"
+          VER="${{ needs.setup.outputs.version }}"
-          echo "bin_url=$BIN_URL" >> "$GITHUB_OUTPUT"
+          BASE_URL="https://github.com/dexoron/dcr/releases/download/${TAG}"
-          echo "sha256=$SHA256" >> "$GITHUB_OUTPUT"
+          for arch in x86_64 aarch64 i686 armv7h riscv64; do
+            case "$arch" in
+              x86_64)  triple="x86_64-unknown-linux-musl" ;;
+              aarch64) triple="aarch64-unknown-linux-musl" ;;
+              i686)    triple="i686-unknown-linux-musl" ;;
+              armv7h)  triple="armv7-unknown-linux-musleabihf" ;;
+              riscv64) triple="riscv64gc-unknown-linux-musl" ;;
+            esac
+            url="${BASE_URL}/dcr-${triple}-${VER}"
+            sha256="$(curl -fsSL "$url" | sha256sum | awk '{print $1}')"
+            echo "${arch}_url=${url}" >> "$GITHUB_OUTPUT"
+            echo "${arch}_sha256=${sha256}" >> "$GITHUB_OUTPUT"
+          done
 
       - name: Render AUR Metadata
         shell: bash
@@ -646,16 +768,13 @@ jobs:
           set -euo pipefail
           PKGVER_ORIG='${{ needs.setup.outputs.version }}'
           PKGVER_CLEAN="${PKGVER_ORIG//-/.}"
-          BIN_URL='${{ steps.meta.outputs.bin_url }}'
-          SHA256='${{ steps.meta.outputs.sha256 }}'
-
           mkdir -p packages/aur/dcr-bin
           cat > packages/aur/dcr-bin/PKGBUILD <<PKG
           pkgname=dcr-bin
           pkgver=${PKGVER_CLEAN}
           pkgrel=1
           pkgdesc="Cargo-like utility to manage C/C++ projects (pre-compiled musl binary)"
-          arch=('x86_64')
+          arch=('x86_64' 'aarch64' 'i686' 'armv7h' 'riscv64')
           url="https://github.com/dexoron/dcr"
           license=('GPL-3.0-or-later')
           provides=('dcr')
@@ -664,8 +783,16 @@ jobs:
             'gcc: build C/C++ projects with GCC'
             'clang: build C/C++ projects with Clang'
           )
-          source_x86_64=("dcr-\$pkgver::${BIN_URL}")
+          source_x86_64=("dcr-\$pkgver::${{ steps.meta.outputs.x86_64_url }}")
-          sha256sums_x86_64=('${SHA256}')
+          sha256sums_x86_64=('${{ steps.meta.outputs.x86_64_sha256 }}')
+          source_aarch64=("dcr-\$pkgver::${{ steps.meta.outputs.aarch64_url }}")
+          sha256sums_aarch64=('${{ steps.meta.outputs.aarch64_sha256 }}')
+          source_i686=("dcr-\$pkgver::${{ steps.meta.outputs.i686_url }}")
+          sha256sums_i686=('${{ steps.meta.outputs.i686_sha256 }}')
+          source_armv7h=("dcr-\$pkgver::${{ steps.meta.outputs.armv7h_url }}")
+          sha256sums_armv7h=('${{ steps.meta.outputs.armv7h_sha256 }}')
+          source_riscv64=("dcr-\$pkgver::${{ steps.meta.outputs.riscv64_url }}")
+          sha256sums_riscv64=('${{ steps.meta.outputs.riscv64_sha256 }}')
 
           package() {
             install -Dm755 "\$srcdir/dcr-\$pkgver" "\$pkgdir/usr/bin/dcr"
@@ -679,13 +806,25 @@ jobs:
             pkgrel = 1
             url = https://github.com/dexoron/dcr
             arch = x86_64
+            arch = aarch64
+            arch = i686
+            arch = armv7h
+            arch = riscv64
             license = GPL-3.0-or-later
             provides = dcr
             conflicts = dcr
             optdepends = gcc: build C/C++ projects with GCC
             optdepends = clang: build C/C++ projects with Clang
-            source_x86_64 = dcr-${PKGVER_CLEAN}::${BIN_URL}
+            source_x86_64 = dcr-${PKGVER_CLEAN}::${{ steps.meta.outputs.x86_64_url }}
-            sha256sums_x86_64 = ${SHA256}
+            sha256sums_x86_64 = ${{ steps.meta.outputs.x86_64_sha256 }}
+            source_aarch64 = dcr-${PKGVER_CLEAN}::${{ steps.meta.outputs.aarch64_url }}
+            sha256sums_aarch64 = ${{ steps.meta.outputs.aarch64_sha256 }}
+            source_i686 = dcr-${PKGVER_CLEAN}::${{ steps.meta.outputs.i686_url }}
+            sha256sums_i686 = ${{ steps.meta.outputs.i686_sha256 }}
+            source_armv7h = dcr-${PKGVER_CLEAN}::${{ steps.meta.outputs.armv7h_url }}
+            sha256sums_armv7h = ${{ steps.meta.outputs.armv7h_sha256 }}
+            source_riscv64 = dcr-${PKGVER_CLEAN}::${{ steps.meta.outputs.riscv64_url }}
+            sha256sums_riscv64 = ${{ steps.meta.outputs.riscv64_sha256 }}
 
           pkgname = dcr-bin
           SRC
@@ -703,22 +842,299 @@ jobs:
           ssh-keyscan aur.archlinux.org >> ~/.ssh/known_hosts
 
           export GIT_SSH_COMMAND='ssh -i ~/.ssh/aur -o IdentitiesOnly=yes'
-          git clone "ssh://aur@aur.archlinux.org/${AUR_PACKAGE}.git" aur-repo
+          
-          cp packages/aur/dcr-bin/PKGBUILD aur-repo/PKGBUILD
+          mkdir -p aur-repo
-          cp packages/aur/dcr-bin/.SRCINFO aur-repo/.SRCINFO
-
           cd aur-repo
+          git init
+          git remote add origin "ssh://aur@aur.archlinux.org/${AUR_PACKAGE}.git"
+          
+          git fetch origin master || true
+          git checkout master || git checkout -b master
+          
+          cp ../packages/aur/dcr-bin/PKGBUILD .
+          cp ../packages/aur/dcr-bin/.SRCINFO .
+
           git config user.name "github-actions[bot]"
           git config user.email "github-actions[bot]@users.noreply.github.com"
 
-          if git diff --quiet; then
+          if git rev-parse --verify HEAD >/dev/null 2>&1; then
-            echo "No AUR changes"
+            if git diff --quiet; then
-            exit 0
+              echo "No AUR changes"
+              exit 0
+            fi
           fi
 
           git add PKGBUILD .SRCINFO
           git commit -m "dcr-bin ${{ needs.setup.outputs.version }}"
-          git push
+          git push -u origin master
+
+
+  # ── Arch User Repository (dcr-dev) ────────────────────────────────
+  publish-aur-dev:
+    if: ${{ (github.event_name == 'push' && needs.setup.outputs.prerelease == 'true') || github.event.inputs.run_aur_dev == 'true' }}
+    needs: [setup]
+    runs-on: ubuntu-latest
+    environment: aur
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+
+      - name: Derive checksum
+        id: meta
+        shell: bash
+        run: |
+          set -euo pipefail
+          SRC_URL="https://github.com/dexoron/dcr/archive/refs/tags/${{ needs.setup.outputs.tag }}.tar.gz"
+          SHA256="$(curl -fsSL "$SRC_URL" | sha256sum | awk '{print $1}')"
+          echo "source_url=$SRC_URL" >> "$GITHUB_OUTPUT"
+          echo "sha256=$SHA256" >> "$GITHUB_OUTPUT"
+
+      - name: Render AUR metadata
+        shell: bash
+        run: |
+          set -euo pipefail
+          PKGVER_ORIG='${{ needs.setup.outputs.version }}'
+          PKGVER_CLEAN='${{ needs.setup.outputs.clean_version }}'
+          SRC_URL='${{ steps.meta.outputs.source_url }}'
+          SHA256='${{ steps.meta.outputs.sha256 }}'
+
+          mkdir -p packages/aur/dcr-dev
+          cat > packages/aur/dcr-dev/PKGBUILD <<PKG
+          pkgname=dcr-dev
+          pkgver=${PKGVER_CLEAN}
+          pkgrel=1
+          pkgdesc="Cargo-like utility to manage C/C++ projects (development release)"
+          arch=('x86_64' 'aarch64')
+          url="https://github.com/dexoron/dcr"
+          license=('GPL-3.0-or-later')
+          depends=('gcc-libs')
+          makedepends=('cargo')
+          options=('!lto')
+          provides=('dcr')
+          conflicts=('dcr')
+          optdepends=(
+            'gcc: build C/C++ projects with GCC'
+            'clang: build C/C++ projects with Clang'
+          )
+          source=("\$pkgname-\$pkgver.tar.gz::${SRC_URL}")
+          sha256sums=('${SHA256}')
+
+          build() {
+            cd "\$srcdir/dcr-${PKGVER_ORIG}"
+            unset CFLAGS CXXFLAGS LDFLAGS
+            export RUSTFLAGS="-C linker=cc"
+            cargo build --release --locked --features archive
+          }
+
+          package() {
+            cd "\$srcdir/\$pkgname-${PKGVER_ORIG}"
+            install -Dm755 "target/release/dcr" "\$pkgdir/usr/bin/dcr"
+            install -Dm644 LICENSE "\$pkgdir/usr/share/licenses/\$pkgname/LICENSE"
+            for manpage in man/man1/*.1; do
+              install -Dm644 "\$manpage" "\$pkgdir/usr/share/man/man1/\$(basename "\$manpage")"
+            done
+          }
+          PKG
+
+          cat > packages/aur/dcr-dev/.SRCINFO <<SRC
+          pkgbase = dcr-dev
+            pkgdesc = Cargo-like utility to manage C/C++ projects (development release)
+            pkgver = ${PKGVER_CLEAN}
+            pkgrel = 1
+            url = https://github.com/dexoron/dcr
+            arch = x86_64
+            arch = aarch64
+            license = GPL-3.0-or-later
+            makedepends = cargo
+            depends = gcc-libs
+            provides = dcr
+            conflicts = dcr
+            optdepends = gcc: build C/C++ projects with GCC
+            optdepends = clang: build C/C++ projects with Clang
+            options = !lto
+            source = dcr-${PKGVER_CLEAN}.tar.gz::${SRC_URL}
+            sha256sums = ${SHA256}
+
+          pkgname = dcr-dev
+          SRC
+
+      - name: Push to AUR
+        env:
+          AUR_SSH_PRIVATE_KEY: ${{ secrets.AUR_SSH_PRIVATE_KEY }}
+          AUR_PACKAGE: dcr-dev
+        shell: bash
+        run: |
+          set -euo pipefail
+          install -d -m 700 ~/.ssh
+          printf '%s\n' "$AUR_SSH_PRIVATE_KEY" > ~/.ssh/aur
+          chmod 600 ~/.ssh/aur
+          ssh-keyscan aur.archlinux.org >> ~/.ssh/known_hosts
+
+          export GIT_SSH_COMMAND='ssh -i ~/.ssh/aur -o IdentitiesOnly=yes'
+          
+          mkdir -p aur-repo
+          cd aur-repo
+          git init
+          git remote add origin "ssh://aur@aur.archlinux.org/${AUR_PACKAGE}.git"
+          
+          git fetch origin master || true
+          git checkout master || git checkout -b master
+          
+          cp ../packages/aur/dcr-dev/PKGBUILD .
+          cp ../packages/aur/dcr-dev/.SRCINFO .
+
+          git config user.name "github-actions[bot]"
+          git config user.email "github-actions[bot]@users.noreply.github.com"
+
+          if git rev-parse --verify HEAD >/dev/null 2>&1; then
+            if git diff --quiet; then
+              echo "No AUR changes"
+              exit 0
+            fi
+          fi
+
+          git add PKGBUILD .SRCINFO
+          git commit -m "dcr-dev ${{ needs.setup.outputs.version }}"
+          git push -u origin master
+
+  # ── Arch User Repository (dcr-dev-bin) ────────────────────────────
+  publish-aur-dev-bin:
+    if: ${{ (github.event_name == 'push' && needs.setup.outputs.prerelease == 'true') || github.event.inputs.run_aur_dev == 'true' }}
+    needs: [setup, build-linux]
+    runs-on: ubuntu-latest
+    environment: aur
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+
+      - name: Derive checksum
+        id: meta
+        shell: bash
+        run: |
+          set -euo pipefail
+          TAG="${{ needs.setup.outputs.tag }}"
+          VER="${{ needs.setup.outputs.version }}"
+          BASE_URL="https://github.com/dexoron/dcr/releases/download/${TAG}"
+          for arch in x86_64 aarch64 i686 armv7h riscv64; do
+            case "$arch" in
+              x86_64)  triple="x86_64-unknown-linux-musl" ;;
+              aarch64) triple="aarch64-unknown-linux-musl" ;;
+              i686)    triple="i686-unknown-linux-musl" ;;
+              armv7h)  triple="armv7-unknown-linux-musleabihf" ;;
+              riscv64) triple="riscv64gc-unknown-linux-musl" ;;
+            esac
+            url="${BASE_URL}/dcr-${triple}-${VER}"
+            sha256="$(curl -fsSL "$url" | sha256sum | awk '{print $1}')"
+            echo "${arch}_url=${url}" >> "$GITHUB_OUTPUT"
+            echo "${arch}_sha256=${sha256}" >> "$GITHUB_OUTPUT"
+          done
+
+      - name: Render AUR Metadata
+        shell: bash
+        run: |
+          set -euo pipefail
+          PKGVER_ORIG='${{ needs.setup.outputs.version }}'
+          PKGVER_CLEAN='${{ needs.setup.outputs.clean_version }}'
+          mkdir -p packages/aur/dcr-dev-bin
+          cat > packages/aur/dcr-dev-bin/PKGBUILD <<PKG
+          pkgname=dcr-dev-bin
+          pkgver=${PKGVER_CLEAN}
+          pkgrel=1
+          pkgdesc="Cargo-like utility to manage C/C++ projects (pre-compiled musl binary dev release)"
+          arch=('x86_64' 'aarch64' 'i686' 'armv7h' 'riscv64')
+          url="https://github.com/dexoron/dcr"
+          license=('GPL-3.0-or-later')
+          provides=('dcr')
+          conflicts=('dcr')
+          optdepends=(
+            'gcc: build C/C++ projects with GCC'
+            'clang: build C/C++ projects with Clang'
+          )
+          source_x86_64=("dcr-\$pkgver::${{ steps.meta.outputs.x86_64_url }}")
+          sha256sums_x86_64=('${{ steps.meta.outputs.x86_64_sha256 }}')
+          source_aarch64=("dcr-\$pkgver::${{ steps.meta.outputs.aarch64_url }}")
+          sha256sums_aarch64=('${{ steps.meta.outputs.aarch64_sha256 }}')
+          source_i686=("dcr-\$pkgver::${{ steps.meta.outputs.i686_url }}")
+          sha256sums_i686=('${{ steps.meta.outputs.i686_sha256 }}')
+          source_armv7h=("dcr-\$pkgver::${{ steps.meta.outputs.armv7h_url }}")
+          sha256sums_armv7h=('${{ steps.meta.outputs.armv7h_sha256 }}')
+          source_riscv64=("dcr-\$pkgver::${{ steps.meta.outputs.riscv64_url }}")
+          sha256sums_riscv64=('${{ steps.meta.outputs.riscv64_sha256 }}')
+
+          package() {
+            install -Dm755 "\$srcdir/dcr-\$pkgver" "\$pkgdir/usr/bin/dcr"
+          }
+          PKG
+
+          cat > packages/aur/dcr-dev-bin/.SRCINFO <<SRC
+          pkgbase = dcr-dev-bin
+            pkgdesc = Cargo-like utility to manage C/C++ projects (pre-compiled musl binary dev release)
+            pkgver = ${PKGVER_CLEAN}
+            pkgrel = 1
+            url = https://github.com/dexoron/dcr
+            arch = x86_64
+            arch = aarch64
+            arch = i686
+            arch = armv7h
+            arch = riscv64
+            license = GPL-3.0-or-later
+            provides = dcr
+            conflicts = dcr
+            optdepends = gcc: build C/C++ projects with GCC
+            optdepends = clang: build C/C++ projects with Clang
+            source_x86_64 = dcr-${PKGVER_CLEAN}::${{ steps.meta.outputs.x86_64_url }}
+            sha256sums_x86_64 = ${{ steps.meta.outputs.x86_64_sha256 }}
+            source_aarch64 = dcr-${PKGVER_CLEAN}::${{ steps.meta.outputs.aarch64_url }}
+            sha256sums_aarch64 = ${{ steps.meta.outputs.aarch64_sha256 }}
+            source_i686 = dcr-${PKGVER_CLEAN}::${{ steps.meta.outputs.i686_url }}
+            sha256sums_i686 = ${{ steps.meta.outputs.i686_sha256 }}
+            source_armv7h = dcr-${PKGVER_CLEAN}::${{ steps.meta.outputs.armv7h_url }}
+            sha256sums_armv7h = ${{ steps.meta.outputs.armv7h_sha256 }}
+            source_riscv64 = dcr-${PKGVER_CLEAN}::${{ steps.meta.outputs.riscv64_url }}
+            sha256sums_riscv64 = ${{ steps.meta.outputs.riscv64_sha256 }}
+
+          pkgname = dcr-dev-bin
+          SRC
+
+      - name: Push to AUR
+        env:
+          AUR_SSH_PRIVATE_KEY: ${{ secrets.AUR_SSH_PRIVATE_KEY }}
+          AUR_PACKAGE: dcr-dev-bin
+        shell: bash
+        run: |
+          set -euo pipefail
+          install -d -m 700 ~/.ssh
+          printf '%s\n' "$AUR_SSH_PRIVATE_KEY" > ~/.ssh/aur
+          chmod 600 ~/.ssh/aur
+          ssh-keyscan aur.archlinux.org >> ~/.ssh/known_hosts
+
+          export GIT_SSH_COMMAND='ssh -i ~/.ssh/aur -o IdentitiesOnly=yes'
+          
+          mkdir -p aur-repo
+          cd aur-repo
+          git init
+          git remote add origin "ssh://aur@aur.archlinux.org/${AUR_PACKAGE}.git"
+          
+          git fetch origin master || true
+          git checkout master || git checkout -b master
+          
+          cp ../packages/aur/dcr-dev-bin/PKGBUILD .
+          cp ../packages/aur/dcr-dev-bin/.SRCINFO .
+
+          git config user.name "github-actions[bot]"
+          git config user.email "github-actions[bot]@users.noreply.github.com"
+
+          if git rev-parse --verify HEAD >/dev/null 2>&1; then
+            if git diff --quiet; then
+              echo "No AUR changes"
+              exit 0
+            fi
+          fi
+
+          git add PKGBUILD .SRCINFO
+          git commit -m "dcr-dev-bin ${{ needs.setup.outputs.version }}"
+          git push -u origin master
+
 
   # ── crates.io ──────────────────────────────────────────────────────────────
   publish-crates:
@@ -738,6 +1154,8 @@ jobs:
       - uses: dtolnay/rust-toolchain@stable
 
       - name: Publish to crates.io
+        env:
+          CARGO_REGISTRY_TOKEN: ${{ secrets.CARGO_REGISTRY_TOKEN }}
         run: cargo publish
 
   # ── Homebrew tap ───────────────────────────────────────────────────────────
@@ -762,6 +1180,7 @@ jobs:
           echo "linux_arm=$(download_sha "dcr-aarch64-unknown-linux-gnu-${VERSION}")"    >> "$GITHUB_OUTPUT"
           echo "macos_x86=$(download_sha "dcr-x86_64-apple-darwin-${VERSION}")"          >> "$GITHUB_OUTPUT"
           echo "macos_arm=$(download_sha "dcr-aarch64-apple-darwin-${VERSION}")"         >> "$GITHUB_OUTPUT"
+          echo "man_pages=$(download_sha "dcr-man-pages-${VERSION}.tar.gz")"             >> "$GITHUB_OUTPUT"
 
       - name: Checkout homebrew-dexoron
         uses: actions/checkout@v4
@@ -804,6 +1223,18 @@ jobs:
               bin.install Dir["dcr*"].first => "dcr"
             end
 
+            resource "man-pages" do
+              url "https://github.com/dexoron/dcr/releases/download/v#{version}/dcr-man-pages-#{version}.tar.gz"
+              sha256 "${{ steps.sha.outputs.man_pages }}"
+            end
+
+            def install
+              bin.install Dir["dcr*"].first => "dcr"
+              resource("man-pages").stage do
+                man1.install Dir["usr/share/man/man1/*.1"]
+              end
+            end
+
             test do
               system "#{bin}/dcr", "--version"
             end
@@ -819,24 +1250,80 @@ jobs:
           git commit -m "dcr ${{ needs.setup.outputs.version }}"
           git push
   
-  # ── Snap Store (dcrup) ─────────────────────────────────────────────────────
+  # ── Snap Store (dcrup) — temporarily disabled ────────────────────────────
-  publish-snap:
+  # Classic confinement was denied for this project (too new).
+  # Snap artifact is still built and attached to the release via
+  # publish-dexoron-packages. Users can install manually:
+  #   sudo snap install --classic --dangerous dcrup_*.snap
+  #
+  # publish-snap:
+  #   if: ...
+
+  # ── Mirror Release to Yandex Object Storage (S3) ─────────────────────────
+  publish-s3:
     if: |
       (github.event_name == 'push' && needs.setup.outputs.prerelease == 'false') ||
-      (github.event_name == 'workflow_dispatch' && github.event.inputs.run_snap == 'true')
+      (github.event_name == 'workflow_dispatch' && github.event.inputs.run_s3 == 'true')
-    needs: [setup, build-linux-packages]
+    needs:
+      - setup
+      - create-release
+      - man-pages
+      - build-linux
+      - build-macos
+      - build-bsd
+      - build-windows
     runs-on: ubuntu-latest
     steps:
-      - name: Download Built Packages
+      - name: Checkout Repository
-        uses: actions/download-artifact@v4
+        uses: actions/checkout@v4
         with:
-          name: snap-package
+          ref: ${{ needs.setup.outputs.tag }}
-          path: dist-packages
+
+      - name: Prepare Directory and Download GitHub Release Assets
+        id: fetch-assets
+        shell: bash
+        run: |
+          set -euo pipefail
+          TAG="${{ needs.setup.outputs.tag }}"
+          
+          mkdir -p dist
+          cd dist
+
+          echo "Downloading assets from GitHub Release for tag: ${TAG}"
+          gh release download "${TAG}" --dir . --repo "${{ github.repository }}"
+          
+          cd ..
+          echo "Archiving source code..."
+          git archive --format=tar.gz --prefix="dcr-${TAG}/" "${TAG}" -o "dist/dcr-src-${TAG}.tar.gz"
+          git archive --format=zip --prefix="dcr-${TAG}/" "${TAG}" -o "dist/dcr-src-${TAG}.zip"
 
-      - name: Publish to Snap Store
-        uses: snapcore/action-publish@v1
         env:
-          SNAPCRAFT_STORE_CREDENTIALS: ${{ secrets.SNAP_STORE_LOGIN }}
+          GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-        with:
+
-          snap: dist-packages/*.snap
+      - name: Upload Everything to Yandex Object Storage
-          release: stable
+        env:
+          AWS_ACCESS_KEY_ID: ${{ secrets.AWS_ACCESS_KEY_ID }}
+          AWS_SECRET_ACCESS_KEY: ${{ secrets.AWS_SECRET_ACCESS_KEY }}
+          AWS_EC2_METADATA_DISABLED: true
+        shell: bash
+        run: |
+          set -euo pipefail
+          TAG="${{ needs.setup.outputs.tag }}"
+
+          aws s3 sync dist/ "s3://${{ secrets.S3_BUCKET_NAME }}/${TAG}/" \
+            --endpoint-url https://storage.yandexcloud.net \
+            --region ru-central1
+
+      - name: Upload Everything to Cloudflare R2
+        env:
+          AWS_ACCESS_KEY_ID: ${{ secrets.R2_ACCESS_KEY_ID }}
+          AWS_SECRET_ACCESS_KEY: ${{ secrets.R2_SECRET_ACCESS_KEY }}
+          AWS_EC2_METADATA_DISABLED: true
+        shell: bash
+        run: |
+          set -euo pipefail
+          TAG="${{ needs.setup.outputs.tag }}"
+
+          aws s3 sync dist/ "s3://${{ secrets.R2_BUCKET_NAME }}/${TAG}/" \
+            --endpoint-url https://${{ secrets.R2_ACCOUNT_ID }}.r2.cloudflarestorage.com \
+            --region auto

.github/workflows/trigger-site-build.yml

@@ -0,0 +1,14 @@
+name: Trigger site rebuild
+
+on:
+  push:
+    branches: [master]
+    paths:
+      - 'docs/**'
+
+jobs:
+  trigger:
+    runs-on: ubuntu-latest
+    steps:
+      - name: Trigger Cloudflare Pages build
+        run: curl -sS -X POST "${{ secrets.CF_PAGES_DEPLOY_HOOK }}"

.gitignore

@@ -2,6 +2,11 @@ target/
 sandbox/**
 .idea/
 .vscode/
+.cargo/
 .env
 
-personal/
+personal/
+.*
+!.gitignore
+!.github/
+graphify-out/

AGENTS.md

@@ -1,56 +0,0 @@
-# AGENTS.md
-
-## Quick start
-
-```bash
-cargo build --release && ./target/release/dcr setup
-```
-
-## Pre-PR (CI) gate
-
-```bash
-cargo fmt --all --check
-cargo clippy --all-targets --all-features -- -D warnings
-cargo check --all-targets --all-features
-cargo test
-```
-
-CI (`.github/workflows/ci.yml`) runs fmt, clippy, check — **not** tests.
-
-## Tests
-
-- Integration tests in `tests/` build the dcr binary and run it in temp dirs under `sandbox/cli-tests/` (gitignored).
-- Some tests **skip** if no C compiler (`gcc`/`clang`/`cc`) is found at runtime.
-- Compiler can be overridden via `DCR_COMPILER` or `DCR_CC` env vars.
-- Tests use `$CARGO_BIN_EXE_dcr` when available, else `target/debug/dcr`.
-
-## Architecture
-
-- **Single Rust package** (edition 2024), not a workspace. Only one binary: `dcr`.
-- **Entrypoint**: `src/main.rs` — matches `args[1]` against command names.
-- **Compiler backends** in `src/core/builder/`: `unix_cc` (gcc/clang), `msvc` (cl/clang-cl), `gas`, `nasm`. Dispatched by matching compiler name string.
-- **Config**: `dcr.toml` (per-project), `~/.dcr/config.toml` (registry), `~/.dcr/index.json` (index). Defaults: `language=c`, `standard=c11`, `compiler=clang`, `kind=bin`.
-- **`build.rs`** embeds `TARGET` as `DCR_TARGET` env var (shown in `--version`).
-- **CLI output** must be in English. Use `utils::log` for messaging.
-
-## Key commands
-
-| Command | Notes |
-|---|---|
-| `dcr new <name>` | Creates project dir |
-| `dcr init` | Init from CWD (must be empty) |
-| `dcr build [--debug\|--release] [--target <triple>]` | Default profile: `--debug` |
-| `dcr run [--debug\|--release]` | Only for `kind = "bin"` |
-| `dcr clean [--debug\|--release] [--all]` | `--all` for workspace roots |
-| `dcr tree` | Dependency tree viewer |
-| `dcr test [--init]` | Runs/test project tests |
-| `dcr gen <vscode\|clion\|compile-commands>` | IDE integration |
-| `dcr --update` | Self-update from GitHub Releases |
-
-## Cross-compilation
-
-`--target` accepts short names (`linux`, `macos`, `windows`) or full triples. In CI, Linux cross-builds use `cargo-zigbuild`. When `build.target` is set in `dcr.toml`, DCR auto-injects `--target=<value>` into cflags (clang). Bare-metal targets (containing `none`/`-elf`/`eabi`/`baremetal`) skip DCR's default compiler flags.
-
-## Dependencies (Cargo)
-
-reqwest (blocking+json+rustls-tls), serde, toml, git2, openssl (vendored), self-replace, sha2, ctrlc.

CHANGELOG.md

@@ -1,5 +1,473 @@
 # Changelog
 
+## [v0.9.0] - 2026-08-31 "Полные Path/Git-зависимости и готовые библиотеки / Complete Path/Git Dependencies & Prebuilt Libraries"
+
+### RU
+
+**Добавлено:**
+
+- **Зеркала загрузок в `dcrup`** — `--mirror auto|cf|gh|sf|ya` и `DCRUP_MIRROR`.
+  По умолчанию `auto`: **cf → gh → sf → ya** (CloudFlare CDN, GitHub, SourceForge, Yandex CDN).
+- **Полные Path/Git-зависимости** — DCR-пакеты из `path` и `git` собираются перед потребителем; Git-код кешируется в `~/.dcr/git`, поддерживает `branch`/`tag`/`rev` и фиксирует точный commit в `dcr.lock`.
+- **Транзитивные зависимости и защита от циклов** — DCR рекурсивно собирает DCR-пакеты и показывает цепочку циклической зависимости.
+- **Внешние готовые библиотеки через path/Git** — `include`, `lib` и `libs` подключают библиотеку без `dcr.toml`; Git prebuilt-источники тоже фиксируются по точному commit.
+- **Явный режим зависимости** — `mode = "build"` и `mode = "prebuild"` позволяют выбрать сборку DCR-пакета или подключение готовых артефактов, даже когда репозиторий содержит оба варианта.
+
+**Удалено:**
+
+- **`install.sh` / `install.ps1` / `install_bsd.sh`** — устарели, заменены `dcrup`.
+
+### EN
+
+**Added:**
+
+- **Download mirrors in `dcrup`** — `--mirror auto|cf|gh|sf|ya` and `DCRUP_MIRROR`.
+  Default `auto` tries **cf → gh → sf → ya** (CloudFlare CDN, GitHub, SourceForge, Yandex CDN).
+- **Complete Path/Git dependencies** — DCR packages from `path` and `git` are built before their consumer; Git sources are cached in `~/.dcr/git`, support `branch`/`tag`/`rev`, and lock the exact commit in `dcr.lock`.
+- **Transitive dependencies and cycle protection** — DCR recursively builds DCR packages and reports the dependency cycle chain.
+- **Prebuilt external libraries through path/Git** — `include`, `lib`, and `libs` link libraries without `dcr.toml`; Git prebuilt sources are locked to their exact commit as well.
+- **Explicit dependency mode** — `mode = "build"` and `mode = "prebuild"` select DCR package builds or ready-made artifacts when a repository contains both forms.
+
+**Removed:**
+
+- **`install.sh` / `install.ps1` / `install_bsd.sh`** — superseded by `dcrup`.
+
+## [v0.8.5] - 2026-08-08 "Фиксация версии dcr-version и предупреждения совместимости / Config Version Pinning & Compatibility Warnings"
+
+### RU
+
+**Добавлено:**
+
+- **`package.dcr-version`** — опциональный pin версии CLI в `dcr.toml`.
+  `dcr new` / `dcr init` пишут текущую версию. При загрузке конфига:
+  - нет / пустой pin → warn «добавь dcr-version»;
+  - dcr старше pin → warn «обнови dcr»;
+  - dcr новее pin → warn «проверь changelog, подними pin»;
+  - равенство — тишина.
+    Команды не падают, только предупреждение (раз на path за процесс).
+
+### EN
+
+**Added:**
+
+- **`package.dcr-version`** — optional CLI version pin in `dcr.toml`.
+  `dcr new` / `dcr init` write the current version. On config load:
+  - missing / empty pin → warn "add dcr-version";
+  - dcr older than pin → warn "update dcr";
+  - dcr newer than pin → warn "check changelog, update pin";
+  - equal → silent.
+    Commands do not fail, warning only (once per path per process).
+
+## [0.8.4] - 2026-08-04 "Инфраструктура .dcr/ и интеграция с IDE / Internal .dcr/ Layout & IDE Integration"
+
+### RU
+
+**Добавлено:**
+
+- **Директория `.dcr/`** — единый machine-readable источник фактов о сборке для IDE/расширений:
+  - `.dcr/compile_commands.json`
+  - `.dcr/build-info.json` (`schemaVersion`, `artifact_path`, `profile`, …)
+  - `.dcr/toolchain.json` (compiler/debugger paths, moc/uic/rcc)
+  - `.dcr/ide/` (заготовки lock-файлов для расширений)
+- **`dcr gen project-info`** — поля `target`, `target_dir`, `artifact_path`, `artifact_kind`, `source_roots`, `include_globs`, `exclude_globs`; пути абсолютные/канонические.
+- **`dcr build --print-artifact-path`** — после успешной сборки одна строка absolute path на stdout.
+- **`dcr gen … --quiet` / `-q`** — без human-лога на stdout для `compile-commands` / `project-info`.
+- **`.clangd`** — при первом `gen` создаётся с `CompilationDatabase: .dcr` (маркер `# managed by dcr gen`); ручной `.clangd` не перезаписывается.
+- **Хелперы** `canonicalize_path`, `atomic_write`, `ensure_dcr_dir`; pure `resolve_artifact_path` через `platform::*`.
+- **`dcr new` / `dcr init`** — `.dcr/` в `.gitignore`.
+
+**Изменено (breaking):**
+
+- **`compile_commands.json` перенесён** из корня проекта в **`.dcr/compile_commands.json`**.  
+  clangd находит базу через `.clangd` / `clangd.arguments --compile-commands-dir=.dcr`.  
+  CLion `misc.xml` и VSCode `settings.json` обновлены под новый путь.
+- **Атомарная запись** `compile_commands.json` (tmp + rename).
+- **`gen vscode` / `gen clion` launch/run** — `program`/`executable` через тот же artifact resolver, что `project-info` / `build-info.json` (Linux triple, Windows `.exe`, custom `target`/`filename`).
+
+**Исправлено:**
+
+- Launch-конфиги больше не указывают `target/<profile>/<name>` без triple на Linux.
+- Симлинки/mount: root и пути в compile database канонизируются best-effort.
+
+### EN
+
+**Added:**
+
+- **`.dcr/` directory** — shared machine-readable build facts for IDE integrations:
+  - `.dcr/compile_commands.json`
+  - `.dcr/build-info.json` (`schemaVersion`, `artifact_path`, `profile`, …)
+  - `.dcr/toolchain.json` (compiler/debugger paths, moc/uic/rcc)
+  - `.dcr/ide/` (placeholder for IDE lock files)
+- **`dcr gen project-info`** — `target`, `target_dir`, `artifact_path`, `artifact_kind`, `source_roots`, `include_globs`, `exclude_globs`; absolute/canonical paths.
+- **`dcr build --print-artifact-path`** — one absolute artifact path line on stdout after a successful build.
+- **`dcr gen … --quiet` / `-q`** — suppress human success logs for gen subcommands.
+- **`.clangd`** — created on first gen with `CompilationDatabase: .dcr` (`# managed by dcr gen`); custom `.clangd` is not overwritten.
+- **Helpers** `canonicalize_path`, `atomic_write`, `ensure_dcr_dir`; pure `resolve_artifact_path` via `platform::*`.
+- **`dcr new` / `dcr init`** — add `.dcr/` to `.gitignore`.
+
+**Changed (breaking):**
+
+- **`compile_commands.json` moved** from project root to **`.dcr/compile_commands.json`**.  
+  clangd discovers it via `.clangd` / `--compile-commands-dir=.dcr`.  
+  CLion and VSCode generators updated accordingly.
+- **Atomic write** for compile_commands (tmp + rename).
+- **`gen vscode` / `gen clion` launch/run** — use the same artifact path resolver as `project-info` / `build-info.json`.
+
+**Fixed:**
+
+- Launch configs no longer hardcode `target/<profile>/<name>` without the Linux triple segment.
+- Symlink/mount roots: best-effort canonicalize for root and compile database paths.
+
+## [0.8.3] - 2026-08-03 "Конфигурация host target, аргументы run и нативные пути артефактов / Host Target Config, Run Args & Native Artifact Paths"
+
+### RU
+
+**Добавлено:**
+
+- **`dcr run -- <args>...`** — cargo-style: всё после bare `--` передаётся собранному бинарнику  
+  (`dcr run --release -- --test_help`). Работает и для прямого запуска, и для `[run].cmd`.
+- **Интеграционные / unit-тесты** — host target sections применяют `ldflags` без `--target`; проброс аргументов после `--`; парсер `split_double_dash`.
+
+**Изменено:**
+
+- **Native-сборка резолвит host triple** — без `--target` / без `build.target` конфиг-секции вида  
+  `[build.x86_64-unknown-linux-gnu]` (и аналоги host) снова применяются (`cflags` / `ldflags` / toolchain).  
+  Раньше target был «пустым», секции молча игнорировались, а артефакты уже лежали под host triple — линковка без `-L`/`-l`.
+- **Пустой target** — `normalize_target_os("")` больше не warn'ит `Unknown target ''`.
+- **`dcr run --help` / man `dcr-run`** — документирован разделитель `--` и forwarding args.
+
+**Исправлено:**
+
+- **Нативные пути артефактов на Windows и macOS** — без явного `--target` / `build.target` артефакты снова сохраняются в `target/<profile>`, поэтому `dcr run` и flat-bin находят результат сборки.
+- Target-specific `ldflags` на native Linux/macOS/Windows (host triple) не доходили до линкера.
+- Ложный warning на пустой target string.
+
+### EN
+
+**Added:**
+
+- **`dcr run -- <args>...`** — cargo-style: arguments after a bare `--` are forwarded to the built binary  
+  (`dcr run --release -- --test_help`). Works for direct binary runs and `[run].cmd`.
+- **Tests** — host target sections apply `ldflags` without CLI `--target`; run-arg forwarding; `split_double_dash` unit tests.
+
+**Changed:**
+
+- **Native builds resolve the host triple** — without `--target` / without package `build.target`, host sections such as  
+  `[build.x86_64-unknown-linux-gnu]` (and host equivalents) apply again (`cflags` / `ldflags` / toolchain).  
+  Previously the target was empty, those sections were silently ignored while artifacts already used the host triple path — link failed without `-L`/`-l` (e.g. sandbox micro-lang + `libsct-elf`).
+- **Empty target** — `normalize_target_os("")` no longer warns `Unknown target ''`.
+- **`dcr run --help` / man `dcr-run`** — document `--` and argument forwarding.
+
+**Fixed:**
+
+- **Native artifact paths on Windows and macOS** — without an explicit `--target` / `build.target`, artifacts again use `target/<profile>`, so `dcr run` and flat-bin find the build output.
+- Target-specific `ldflags` on native host builds not reaching the linker.
+- Spurious warning for an empty target string.
+
+## [0.8.2] - 2026-07-22 "CLI Progress, archive Feature, Workspace Path Fixes / CLI Progress, archive Feature, Workspace Path Fixes"
+
+### RU
+
+**Добавлено:**
+
+- **Прогресс компиляции `[N/M]`** — live-строка `compile  pkg v0.1.0  [12/41]` на TTY (stderr), чтобы длинные mono-package сборки не выглядели «зависшими».
+- **Свой стиль статуса build** — фиксированная колонка глаголов: `project`, `compile`, `dep`, `ready`, `pack`, `done`, `run` (не cargo-clone).
+- **Cargo feature `archive`** — `fatfs` и упаковка FAT-образов опциональны (`cargo build --features archive`). Release CI собирает с feature; без feature `[archive]` даёт явную ошибку.
+- **Интеграционные тесты** — `flat_bin_nasm_build`, `package_build_target_used_without_cli_flag`, усилен workspace `clean --all`.
+- **Расширенный CI** — unit + integration на Linux/macOS/Windows, отдельный job с `--features archive`, rust-cache, clippy default + all-features.
+
+**Изменено:**
+
+- **CLI host triple больше не форсится** — без `--target` используется `build.target` пакета/member (важно для bare-metal / post_steps ISO).
+- **Relative `-I`/`-L`/`-T` (и `-isystem`/`-idirafter`)** в cflags/ldflags абсолютизируются относительно корня пакета (workspace CWD = root).
+- **`dcr clean --all`** — не спамит `target not found` по members без локального `target/` (общий root `target/`).
+- **`error` / `warn`** — красный / жёлтый, вывод на stderr; `Подсказка:` → `Hint:`.
+- **`dcr --help` / man** — добавлены `add`, `lint`, `setup`; unknown command → exit code 1.
+- **Сообщения NotFound** — `linker not found: ld.lld …` / `{tool} not found …` вместо сырого `os error 2`.
+
+### EN
+
+**Added:**
+
+- **Compile progress `[N/M]`** — live TTY line `compile  pkg v0.1.0  [12/41]` so long mono-package builds do not look hung.
+- **DCR status verbs** — fixed-width column: `project`, `compile`, `dep`, `ready`, `pack`, `done`, `run`.
+- **Cargo feature `archive`** — optional `fatfs` / FAT packing (`cargo build --features archive`). Release CI builds with the feature; without it `[archive]` errors clearly.
+- **Integration tests** — `flat_bin_nasm_build`, package `build.target` without CLI flag, stricter workspace `clean --all`.
+- **Expanded CI** — unit + integration on Linux/macOS/Windows, archive feature job, rust-cache, clippy default + all-features.
+
+**Changed:**
+
+- **CLI no longer forces host triple** — without `--target`, package/member `build.target` is used (bare-metal / ISO post_steps).
+- **Relative `-I`/`-L`/`-T` (and `-isystem`/`-idirafter`)** in flags are absolutized against the package root when workspace CWD is the root.
+- **`dcr clean --all`** — no spam for members without a local `target/` (shared root `target/`).
+- **`error` / `warn`** — red / yellow on stderr; Russian `Подсказка:` → `Hint:`.
+- **`dcr --help` / man** — list `add`, `lint`, `setup`; unknown command exits 1.
+- **NotFound messages** — `linker not found: ld.lld …` / `{tool} not found …` instead of raw `os error 2`.
+
+## [0.8.1] - 2026-07-20 "OS-Dev: flat-bin, FAT-образы / OS-Dev: flat-bin & FAT Images"
+
+### RU
+
+**Добавлено:**
+
+- **`build.kind = "flat-bin"`** — сырой бинарный артефакт (расширение по умолчанию `.bin`):
+  - **NASM** — `-f bin`, прямой вывод `<stem>.bin`
+  - **FASM** — прямой вывод (ожидается `format binary` в исходнике)
+  - **GAS / MASM / LLVM IR (`llc`)** — объект → `objcopy -O binary` → `<stem>.bin`
+  - **C/C++ (gcc/clang/MSVC)** — compile → link (nostdlib/static) → `objcopy -O binary` → `<name>.bin`
+  - Требуется `llvm-objcopy` / `objcopy` / `gobjcopy` в PATH (кроме NASM/FASM direct)
+- **Секция `[archive]`** — после успешной сборки DCR собирает образ диска (FAT12/16/32): размер, offset, volume label, опциональный bootsector и `layout`. С 0.8.2 — за feature `archive`.
+- **Одиночные файлы в `build.roots`** — корень может быть файлом (`.c`, `.asm`, header), а не только каталогом.
+
+**Изменено:**
+
+- **`dcr build --force` / `dcr run --force`** — force также перезапускает `build.steps` и `build.post_steps`.
+- **`dcr run` на workspace-only root** — если задан `[run].cmd`, сначала build + run по конфигу корня; иначе делегирование члену workspace.
+
+### EN
+
+**Added:**
+
+- **`build.kind = "flat-bin"`** — raw binary (default `.bin`) across NASM/FASM/GAS/MASM/LLC and C/C++ (objcopy where needed).
+- **`[archive]` section** — FAT12/16/32 disk images after build (from 0.8.2 gated by feature `archive`).
+- **Single-file `build.roots`**.
+
+**Changed:**
+
+- **`--force`** re-runs steps/post_steps; workspace-only **`dcr run`** prefers root `[run].cmd` when set.
+
+## [0.8.0] - 2026-07-18 "Модульный Движок Сборки, Новая Архитектура Ядра и Улучшение Workspaces / Modular Build Engine, New Core Architecture, & Workspace Improvements"
+
+### RU
+
+**Добавлено:**
+
+- **Выделенное ядро сборки (Build Engine extraction)** — вся логика оркестрации компиляции и сборки полностью вынесена из интерфейсного модуля `src/cli/build.rs` в изолированный, переиспользуемый модуль ядра `src/core/build/engine.rs`.
+- **Полиморфная модель языков (Трейт `Language`)** — введение абстрактного трейта `Language` (`src/core/build/language/mod.rs`). Логика поиска файлов, сопоставления расширений и компиляторов распределена по выделенным языковым бэкендам для C, C++ (включая шаги генерации Qt), LLVM IR и ассемблера (GAS, NASM, FASM, MASM).
+- **Абстракция сборщиков (Трейт `Builder`)** — введение трейта `Builder` для полиморфного управления процессами компиляции (`src/core/build/builder/mod.rs`). Логика вызова компиляторов семейства GCC/Clang вынесена в общий модуль `builder/cc_common.rs`, а MSVC — в `builder/msvc/`.
+- **Поязыковая конфигурация (`[build.<lang>]`)** — добавлена поддержка индивидуальных настроек для каждого языка в `dcr.toml` (например, `[build.c]`, `[build.cpp]`, `[build.asm]`), позволяя независимо настраивать компилятор, стандарт и флаги сборки.
+- **Интеграция путей зависимостей в Workspaces** — сборщик теперь автоматически инжектирует пути заголовков (включая исходники `src/` членов, папки `include/` и директорию `target/include`) и библиотек (`target/lib`, а также специфичные для целевой платформы папки сборки) зависимых членов workspace при сборке.
+- **Система событий `BuildReporter`** — весь вывод сборщика переведён на событийную модель (`src/core/build/report.rs`), что делает движок пригодным для программного встраивания (например, в IDE) без необходимости перехвата stdout/stderr.
+- **Поддержка отмены сборки** — добавлен потокобезопасный токен отмены (`Arc<AtomicBool>`), позволяющий безопасно прервать выполнение компиляции на любом этапе.
+- **Сохранение кастомных ключей TOML** — парсер `dcr.toml` переведен на `toml_edit`, что гарантирует сохранение всех неизвестных/пользовательских ключей, комментариев и форматирования при перезаписи файла (например, через `dcr add`).
+- **Разрешение заголовков для локальных path-зависимостей** — исправлена проблема, при которой потребители не могли найти заголовочные файлы статических/динамических библиотек, лежащие в упакованной папке `target/include` локальных path-зависимостей.
+- **Новая система интеграционных тестов** — старый громоздкий файл `tests/cli_basic.rs` разделен на изолированные и структурированные интеграционные тесты для каждой команды и фичи: `cli_build.rs`, `cli_deps.rs`, `cli_lint.rs`, `cli_new.rs`, `cli_qt.rs`, `cli_test.rs`, `cli_workspace.rs`.
+
+**Изменено:**
+
+- **Дедупликация генерации артефактов** — логика линковки бинарных файлов (ELF, PE, EXE), динамических библиотек (`.so`, `.dll`, `.dylib`) и архивации статических библиотек (`.a`, `.lib`) полностью перенесена в выделенный модуль `src/core/build/builder/artifact.rs`.
+- **Запуск членов workspace из корня** — команда `dcr run` при вызове из корня workspace-only проекта теперь запускает сборку выбранного пакета в контексте workspace (через флаг `--workspace`), исключая изолированные ошибки сборки.
+- **Отказ от глобального состояния** — все операции сборки изолированы внутри структуры `BuildContext`, обеспечивая многопоточную безопасность сборщика.
+- **Вынос логики кэширования** — проверка инкрементальных изменений, отслеживание заголовков (`#include`) и вычисление хэшей сборки перенесено в изолированный модуль `src/core/build/cache.rs`.
+- **Модуляризация кастомных шагов** — обработка этапа `build.steps` для препроцессоров вынесена в `src/core/build/steps.rs`.
+
+### EN
+
+**Added:**
+
+- **Dedicated Build Engine (`src/core/build/engine.rs`)** — decoupled the build orchestration logic completely from the CLI front-end wrapper in `src/cli/build.rs` to a reusable, decoupled core build engine.
+- **Polymorphic Language Model (`Language` trait)** — introduced the abstract `Language` trait (`src/core/build/language/mod.rs`). File scanning, compiler resolution, and flags handling are now encapsulated in dedicated language modules for C, C++ (including Qt code generation), LLVM IR, and ASM (GAS, NASM, FASM, MASM).
+- **Polymorphic Compilation Dispatch (`Builder` trait)** — introduced the `Builder` trait to generalize builder invocations (`src/core/build/builder/mod.rs`). Consolidated GCC/Clang logic into `builder/cc_common.rs` and Microsoft Visual C++ logic into `builder/msvc/`.
+- **Per-Language Configuration overrides (`[build.<lang>]`)** — introduced support for configuring language-specific compiler, standard, and flags (e.g. `[build.c]`, `[build.cpp]`, `[build.asm]`) independently in `dcr.toml`.
+- **Automatic Workspace Dependency Injection** — during workspace builds, include/lib paths of dependent workspace members (including their source headers, local `include/` folders, and build target `target/include` / `target/lib` folders) are automatically resolved and injected.
+- **`BuildReporter` Event System** — decoupled build orchestration output into a structured event-driven reporter model (`src/core/build/report.rs`), making DCR suitable for library embedding and IDE integrations without stderr capturing.
+- **Build Cancellation Support** — introduced thread-safe cancellation tokens (`Arc<AtomicBool>`) allowing clients to safely abort compile runs mid-execution.
+- **TOML Formatting & Custom Keys Preservation** — migrated the config editor to `toml_edit`, preserving all unknown/user-defined TOML keys, structures, and comments during file write operations (e.g., in `dcr add`).
+- **Path Dependencies Target Include Resolution** — local path dependencies configured via tables now correctly expose headers built and packaged into their `target/include` folder to consumer packages.
+- **Modular Integration Test Suite** — refactored the monolith `tests/cli_basic.rs` file into clean, specialized integration tests: `cli_build.rs`, `cli_deps.rs`, `cli_lint.rs`, `cli_new.rs`, `cli_qt.rs`, `cli_test.rs`, `cli_workspace.rs`.
+
+**Changed:**
+
+- **Consolidated Linking and Archiving** — artifact generation (linking executables/shared libraries and archiving static libraries) consolidated into a single `src/core/build/builder/artifact.rs` module.
+- **Workspace-Aware member execution** — `dcr run` executed at the workspace root of a `workspace_only` project now triggers the member build inside the workspace context using the `--workspace` parameter, preventing standalone build issues.
+- **Elimination of Global State** — removed global variables and states from the build core, encapsulating build logic inside isolated `BuildContext` structs for thread safety.
+- **Build Cache Separation** — relocated mtime tracking, incremental caching, and header-dependency checking logic to `src/core/build/cache.rs`.
+- **Modularized Pre-build Steps** — decoupled generator scripts and pre-build commands parsing into `src/core/build/steps.rs`.
+
+## [0.7.4] - 2026-06-17 "Qt Поддержка, Linting и Рефакторинг Архитектуры / Qt Support, Linting, & Architecture Refactor"
+
+### RU
+
+**Добавлено:**
+
+- **Нативная поддержка Qt** — добавлена автоматическая обработка мета-объектов (MOC, UIC, RCC) при включении `build.qt = true` в `dcr.toml`.
+- **Команда `dcr lint`** — статический анализ C/C++ через `clang-tidy`. Поддерживает `--fix` для автоматического исправления. Уважает `build.roots` и `build.src_disable` из конфига.
+- **Три новых ассемблерных бэкенда**:
+  - **MASM** (`compiler = "ml"` / `"ml64"`) — Microsoft Macro Assembler.
+  - **FASM** (`compiler = "fasm"`) — Flat Assembler.
+  - **LLVM IR** (`compiler = "llc"`) — компиляция `.ll` → объектный файл.
+- **Общий ASM-пайплайн** — линковка и архивирование вынесены в `core/builder/asm.rs`. Новый ассемблерный бэкенд теперь пишется за ~30 строк.
+- **Утилиты для файловой системы** — `to_hex()` и `home_dir()` вынесены в `utils/fs.rs`.
+- **Утилиты для сборки** — `normalize_target()`, `normalize_kind()`, `normalize_platform()`, `default_profile_flags()` вынесены в `utils/build.rs`.
+- **Утилиты для бэкендов** — `asm_lang_flag()`, `source_extensions()`, `elapsed_secs()` добавлены в `core/builder/common.rs`.
+
+- **Полноценная автоматизация Bare-Metal / Freestanding** — добавлен конфигурационный флаг `build.freestanding = true`. При его включении (или при обнаружении bare-metal таргета) DCR автоматически инжектирует флаг `-ffreestanding` на этапе компиляции, а также `-nostdlib` и `-static` на этапе линковки.
+- **Оптимизация артефактов (LTO и Strip)** — в `dcr.toml` добавлены параметры `build.lto` (авто-инжекция флага `-flto` для компилятора и линкера) и `build.strip` (автоматическое отсекание отладочной информации через флаг `-s` линкера).
+- **Контроль многопоточности сборки** — добавлен параметр `build.codegen-units`, позволяющий жестко ограничить максимальное количество параллельных потоков сборки для кастомного движка `parallel_build`.
+- **Управление паникой (Panic Abort)** — добавлен параметр `build.panic = "abort"`. Для C++ проектов он автоматически отключает генерацию таблиц раскрутки стека и исключений через флаги `-fno-exceptions`, `-fno-unwind-tables` и `-fno-asynchronous-unwind-tables`.
+
+**Изменено:**
+
+- **Интеллектуальные дефолтные флаги (DCR Defaults)** — генерация дефолтных флагов оптимизации (`-O3`/`-O0`), отладки (`-g`) и предупреждений (`-Wall -Wextra`) теперь автоматически отключается для bare-metal и freestanding целей, если пользователь переопределил `build.cflags`.
+- **Глобальный вынос bare-metal детектора** — функция `is_bare_metal_target` вынесена в общие утилиты `src/utils/build.rs` для сквозного использования в конвейере сборки.
+- **Рефакторинг архитектуры**:
+  - `src/config.rs` переименован в `src/templates.rs`.
+  - Начата консолидация конфигурационной логики и оркестрации сборки.
+
+### EN
+
+**Added:**
+
+- **Native Qt support** — automatic meta-object handling (MOC, UIC, RCC) added when `build.qt = true` is set in `dcr.toml`.
+- **`dcr lint` command** — C/C++ static analysis via `clang-tidy`. Supports `--fix` for automatic fixes. Respects `build.roots` and `build.src_disable` from config.
+- **Three new assembler backends**:
+  - **MASM** (`compiler = "ml"` / `"ml64"`) — Microsoft Macro Assembler.
+  - **FASM** (`compiler = "fasm"`) — Flat Assembler.
+  - **LLVM IR** (`compiler = "llc"`) — compiles `.ll` files via `llc -filetype=obj`.
+- **Shared ASM pipeline** — linking and archiving logic consolidated into `core/builder/asm.rs`. Adding a new assembler backend now takes ~30 lines.
+- **Filesystem utilities** — `to_hex()` and `home_dir()` extracted to `utils/fs.rs`.
+- **Build utilities** — `normalize_target()`, `normalize_kind()`, `normalize_platform()`, `default_profile_flags()` extracted to `utils/build.rs`.
+- **Backend helpers** — `asm_lang_flag()`, `source_extensions()`, `elapsed_secs()` added to `core/builder/common.rs`.
+
+- **Full Bare-Metal / Freestanding Automation** — introduced the `build.freestanding = true` configuration option. When enabled (or when a bare-metal target is detected), DCR automatically injects `-ffreestanding` during compilation and both `-nostdlib` and `-static` during linking.
+- **Artifact Optimization (LTO & Strip)** — added `build.lto` (auto-injects `-flto` for compiler and linker) and `build.strip` (automatically strips debug symbols via linker `-s` flag) options to `dcr.toml`.
+- **Compilation Thread Control** — added the `build.codegen-units` option to strictly limit the maximum number of parallel jobs utilized by the custom `parallel_build` worker pool.
+- **Panic Behavior Management** — added `build.panic = "abort"` support. For C++ targets, it automatically strips exception handling and unwind tables via `-fno-exceptions`, `-fno-unwind-tables`, and `-fno-asynchronous-unwind-tables`.
+
+**Changed:**
+
+- **Intelligent Default Flags Generation** — automated injection of fallback optimization (`-O3`/`-O0`), debug (`-g`), and warning (`-Wall -Wextra`) flags is now suppressed for bare-metal and freestanding builds if `build.cflags` are overridden.
+- **Centralized Bare-Metal Detection** — relocated the `is_bare_metal_target` helper to common build utilities (`src/utils/build.rs`) for unified access across the building core.
+- **Architectural Refactoring**:
+  - Renamed `src/config.rs` to `src/templates.rs`.
+  - Started consolidation of configuration and build orchestration logic.
+
+## [0.7.3] - 2026-06-13 "Оптимизация Зависимостей и VCS / Dependency Optimization & VCS"
+
+### RU
+
+**Добавлено:**
+
+- **Параметр `--vcs` для команд `new` и `init`** — добавлена возможность явно указывать систему контроля версий через `--vcs <git|none>`.
+- **Интеграция Git-информации в `--version`** — утилита теперь выводит текущий короткий хэш коммита и суффикс `-dirty`, если в репозитории DCR есть незакоммиченные изменения.
+- **Автоматическая генерация `.gitignore`** — при инициализации Git-репозитория автоматически создается файл `.gitignore` с исключением директории `/target`.
+- **Защита от вложенных репозиториев** — автоматическая инициализация Git теперь пропускается, если `dcr new` или `dcr init` запускаются внутри уже существующего Git-репозитория.
+- **Тесты для верификации VCS** — добавлены интеграционные тесты `new_vcs_options_work` и `init_vcs_options_work` для проверки логики инициализации репозиториев.
+
+**Изменено:**
+
+- **Полный отказ от библиотеки `git2`** — работа с Git (клонирование зависимостей, инициализация VCS, проверка статуса) переведена на вызовы системного `git` через `Command`. Это облегчает сборку проекта и убирает необходимость в фичах `vendored` и `openssl`.
+- **Миграция с `reqwest` на `ureq`** — в модуле обновления (`flag_update.rs`) тяжелый `reqwest` заменен на легковесный синхронный клиент `ureq 2.10`, что уменьшило оверхед и размер итогового бинарника.
+
+### EN
+
+**Added:**
+
+- **`--vcs` option for `new` and `init` commands** — introduced explicit version control system selection via `--vcs <git|none>`.
+- **Git metadata integration in `--version`** — the CLI now appends the current short commit hash and a `-dirty` suffix if there are uncommitted changes in the DCR repository.
+- **Automatic `.gitignore` generation** — Git repository initialization now automatically writes a `.gitignore` file excluding the `/target` directory.
+- **Nested repository prevention** — automatic Git initialization is now skipped if `dcr new` or `dcr init` is executed inside an already existing Git repository.
+- **VCS verification tests** — added `new_vcs_options_work` and `init_vcs_options_work` integration tests to ensure reliable repository behavior.
+
+**Changed:**
+
+- **Complete removal of `git2` dependency** — all Git actions (dependency fetching, VCS setup, status checks) are now delegated to the system `git` executable via `Command`. This simplifies compilation and drops the need for `vendored` and `openssl` features.
+- **Migrated from `reqwest` to `ureq`** — replaced the heavy `reqwest` crate in `flag_update.rs` with the lightweight synchronous `ureq 2.10` client, reducing overhead and the final binary size.
+
+## [0.7.2] - 2026-06-07 "Исправление Таргетов и Линковки / Target & Linker Fixes"
+
+### RU
+
+**Добавлено:**
+
+- Учтён `target_env` в `default_target_triple()` — Linux (gnu/musl) и Windows (msvc/gnu) теперь используют правильное окружение, а не хардкод.
+
+**Исправлено:**
+
+- **Сборка на macOS Apple Silicon падала с `_main` undefined** — `--target=` теперь передаётся и в ldflags, не только в cflags. `default_target_triple()` на macOS использует `std::env::consts::ARCH` вместо хардкода `x86_64`.
+- **Бейджи GitHub Stars и GPL-3.0 не рендерились в README** — блок бейджей переведён на чистый HTML.
+
+**Изменено:**
+
+- Вычисление таргета по умолчанию вынесено в общую функцию `default_target_triple()` — устранено дублирование в build, run, clean.
+
+### EN
+
+**Added:**
+
+- `default_target_triple()` now respects `target_env` — Linux (gnu/musl) and Windows (msvc/gnu) use the correct environment instead of hardcoded values.
+
+**Fixed:**
+
+- **macOS Apple Silicon builds failed with `_main` undefined** — `--target=` is now passed to ldflags, not just cflags. `default_target_triple()` uses `std::env::consts::ARCH` on macOS instead of hardcoded `x86_64`.
+- **GitHub Stars and GPL-3.0 badges not rendering in README** — badge block converted to pure HTML.
+
+**Changed:**
+
+- Default target resolution extracted into shared `default_target_triple()` — removed duplication across build, run, clean.
+
+## [0.7.1] - 2026-06-02 "Мультиархитектурное расширение / The Multi-Arch Expansion"
+
+### RU
+
+**Добавлено:**
+
+- Вывод `--help` для всех команд с цветным форматированием.
+- man-страницы (12 штук в `man/man1/`) и их установка во всех пакетах.
+- Валидация имен проектов в `dcr init` и `dcr new` (только ASCII буквы, цифры, `_` и `-`).
+- Метаданные `documentation` и `homepage` в `Cargo.toml`.
+- Оптимизация сборки: `opt-level = "z"`, LTO, `codegen-units = 1`, `panic = "abort"`, `strip = true`.
+- Поддержка новых архитектур (i686, armv7, riscv64gc, aarch64) в рабочих процессах и установочных скриптах.
+- Сборка пакетов `deb` и `rpm` для всех 5 архитектур Linux через `cargo-zigbuild`.
+- Пакеты AUR (`dcr-dev`, `dcr-dev-bin`) и сборка Snap в CI.
+
+**Изменено:**
+
+- Функция `validate_package_name` стала публичной.
+- Команды `gen`, `tree`, `fmt`, `setup` больше не игнорируют аргументы и используют цветной вывод.
+- Инструкция в README изменена с `| bash` на `| sh` для POSIX.
+- Отключена архитектура Windows 32-bit (GNU) из-за проблем со сборкой.
+
+**Исправлено:**
+
+- **`dcr new <invalid-name>` создаёт директорию, затем падает** — валидация теперь происходит до операций с файлами.
+- **`dcr init` создаёт dcr.toml, затем падает при невалидном имени директории** — то же исправление.
+- **Man-страницы отсутствовали после установки** — теперь устанавливаются через скрипты установки, пакетные менеджеры и Homebrew.
+- **Ложное срабатывание на букву диска в Windows** — в парсинге файлов зависимостей.
+- **CRLF `\r\n` ломает парсер зависимостей** — теперь обрабатываются смешанные окончания строк.
+- **Новая строка после обратного слеша не поглощалась** — в обработке escape-последовательностей `parse_d_file`.
+
+### EN
+
+**Added:**
+
+- `--help` for all commands with styled headers and usage lines.
+- Man pages (12 troff man pages in `man/man1/`) and their installation across all packaging formats.
+- Project name validation in `dcr init` and `dcr new` (ASCII letters, digits, `_`, `-` only).
+- `documentation` and `homepage` metadata in `Cargo.toml`.
+- Release profile optimizations (`opt-level = "z"`, LTO, `codegen-units = 1`, `panic = "abort"`, `strip = true`).
+- Linux i686, armv7, riscv64gc, aarch64 architecture support in release workflows and installation scripts.
+- Multi-arch `deb` and `rpm` package builds for all 5 Linux architectures via `cargo-zigbuild`.
+- AUR packages (`dcr-dev`, `dcr-dev-bin`) and Snap build in CI.
+
+**Changed:**
+
+- `validate_package_name` made public and callable from CLI commands directly.
+- `gen.rs`, `tree.rs`, `fmt.rs`, `setup.rs` no longer ignore arguments and use styled output.
+- README install instructions changed from `| bash` to `| sh` for POSIX compatibility.
+- Disabled Windows 32-bit (GNU) target due to build issues.
+
+Fixed:
+
+- **`dcr new <invalid-name>` creates directory then fails** — validation now happens
+  before any file operations.
+- **`dcr init` creates dcr.toml then fails on invalid directory name** — same fix.
+- **Man pages missing after installation** — now installed via install scripts,
+  package managers, and Homebrew.
+- **Windows drive letter false positive** — in dependency file parsing.
+- **CRLF `\r\n` breaks dependency parser** — now handles mixed line endings.
+- **Newline after backslash not consumed** — in `parse_d_file` escape handling.
+
 ## [0.7.0] - 2026-06-02
 
 Added:
@@ -160,6 +628,7 @@ Added:
   ```
 
   Produces `KERNEL.EFI` (works for `bin`, `staticlib`, and `sharedlib`).
+
 - Automatic injection of `--target=<build.target>` into compiler flags when `build.target` is set in `dcr.toml`. This greatly simplifies clang-based cross-compilation (especially for bare-metal targets like `aarch64-none-elf`).
 - Bare-metal targets (containing `none`, `-elf`, `eabi`, `baremetal`) no longer receive DCR's internal default flags (`-g`, `-Wall`, `-Wextra`, `-fno-omit-frame-pointer`, `-DDCR_DEBUG`, etc.). Prevents unwanted sections (`.comment`, debug info, etc.) that break custom linker scripts when `inherit = true`.
 - `build.ldscript` in `dcr.toml` — linker script path passed as `-T <path>` to the linker. Essential for bare-metal/embedded/freestanding targets.
@@ -194,28 +663,28 @@ Fixed:
 
 - Path dependencies now work correctly: `dcr add` stores them as `{ path =
 "./..." }` tables, `is_registry_dep` properly distinguishes registry strings
-from path/git strings, and `deps/mod.rs` resolves both table-form and
+  from path/git strings, and `deps/mod.rs` resolves both table-form and
-legacy string-form path dependencies
+  legacy string-form path dependencies
 - Registry dependency paths no longer hardcoded to `project_root/dcr-index`;
-now use `package_root_from_registry_info()` which resolves relative to the
+  now use `package_root_from_registry_info()` which resolves relative to the
-registry cache root (`~/.dcr/`)
+  registry cache root (`~/.dcr/`)
 - Registry dependencies are now actually built: `build_project_at()` is
-called when `include_dir` or `lib_dir` is missing
+  called when `include_dir` or `lib_dir` is missing
 
 Added:
 
 - `SIGINT`/`Ctrl+C` handler via `ctrlc` crate — `dcr build` now checks
-`BUILD_INTERRUPTED` flag at key points and aborts cleanly
+  `BUILD_INTERRUPTED` flag at key points and aborts cleanly
 - `utils/build.rs` — extracted shared utilities: `parse_version_info`,
-`normalize_target_os`, `resolve_compiler`, `primary_language`,
+  `normalize_target_os`, `resolve_compiler`, `primary_language`,
-`resolve_pkg_config_flags` and config helpers. Eliminates code duplication
+  `resolve_pkg_config_flags` and config helpers. Eliminates code duplication
-between `cli/build.rs`, `cli/run.rs`, `cli/clean.rs`, `cli/gen.rs`
+  between `cli/build.rs`, `cli/run.rs`, `cli/clean.rs`, `cli/gen.rs`
 - `utils/fs.rs::with_dir` — extracted common directory-scoped execution
 - `run_command_sync_output` in `builder/common.rs` with global `OUTPUT_MUTEX`
-— synchronized compiler output across all backends (unix_cc, gas, nasm, msvc)
+  — synchronized compiler output across all backends (unix_cc, gas, nasm, msvc)
 - New helper functions in `deps/register.rs`: `get_registry_cache_root`,
-`package_root_from_registry_info`, `registry_include_dir`, `registry_lib_dir`,
+  `package_root_from_registry_info`, `registry_include_dir`, `registry_lib_dir`,
-`path_from_string_dep`
+  `path_from_string_dep`
 - Unit tests for `register.rs` (`is_registry_dep`, `package_root_from_registry_info`),
   `deps/mod.rs` (`path_dep_path`, `push_default_lib_dirs`),
   `utils/build.rs` (`normalize_target_os`, `parse_version_info`)

CONTRIBUTING.md

@@ -11,6 +11,7 @@ Thanks for your interest in the project.
 
 ```bash
 git clone https://github.com/dexoron/dcr.git
+# or a source mirror: GitVerse / SourceCraft / SourceForge / GitLab (see README)
 cd dcr
 cargo check
 ```

Cargo.toml

@@ -1,11 +1,13 @@
 [package]
 name = "dcr"
-version = "0.7.0"
+version = "0.9.0"
 edition = "2024"
 build = "build.rs"
 description = "DCR is a utility for managing C/C++ projects in a Cargo-like style."
 license = "GPL-3.0-or-later"
 repository = "https://github.com/dexoron/dcr"
+documentation = "https://dcr-tool.ru/docs"
+homepage = "https://dcr-tool.ru"
 
 [package.metadata.binstall]
 pkg-fmt = "bin"
@@ -21,6 +23,18 @@ section = "devel"
 priority = "optional"
 assets = [
     ["target/release/dcr", "usr/bin/dcr", "755"],
+    ["man/man1/dcr.1", "usr/share/man/man1/dcr.1", "644"],
+    ["man/man1/dcr-add.1", "usr/share/man/man1/dcr-add.1", "644"],
+    ["man/man1/dcr-build.1", "usr/share/man/man1/dcr-build.1", "644"],
+    ["man/man1/dcr-clean.1", "usr/share/man/man1/dcr-clean.1", "644"],
+    ["man/man1/dcr-fmt.1", "usr/share/man/man1/dcr-fmt.1", "644"],
+    ["man/man1/dcr-gen.1", "usr/share/man/man1/dcr-gen.1", "644"],
+    ["man/man1/dcr-init.1", "usr/share/man/man1/dcr-init.1", "644"],
+    ["man/man1/dcr-new.1", "usr/share/man/man1/dcr-new.1", "644"],
+    ["man/man1/dcr-run.1", "usr/share/man/man1/dcr-run.1", "644"],
+    ["man/man1/dcr-setup.1", "usr/share/man/man1/dcr-setup.1", "644"],
+    ["man/man1/dcr-test.1", "usr/share/man/man1/dcr-test.1", "644"],
+    ["man/man1/dcr-tree.1", "usr/share/man/man1/dcr-tree.1", "644"],
 ]
 
 [package.metadata.generate-rpm]
@@ -30,22 +44,57 @@ Cargo-like utility to manage C/C++ projects.
 """
 
 assets = [
-    { source = "target/release/dcr", dest = "/usr/bin/dcr", mode = "755" }
+    { source = "target/release/dcr", dest = "/usr/bin/dcr", mode = "755" },
+    { source = "man/man1/dcr.1", dest = "/usr/share/man/man1/dcr.1", mode = "644" },
+    { source = "man/man1/dcr-add.1", dest = "/usr/share/man/man1/dcr-add.1", mode = "644" },
+    { source = "man/man1/dcr-build.1", dest = "/usr/share/man/man1/dcr-build.1", mode = "644" },
+    { source = "man/man1/dcr-clean.1", dest = "/usr/share/man/man1/dcr-clean.1", mode = "644" },
+    { source = "man/man1/dcr-fmt.1", dest = "/usr/share/man/man1/dcr-fmt.1", mode = "644" },
+    { source = "man/man1/dcr-gen.1", dest = "/usr/share/man/man1/dcr-gen.1", mode = "644" },
+    { source = "man/man1/dcr-init.1", dest = "/usr/share/man/man1/dcr-init.1", mode = "644" },
+    { source = "man/man1/dcr-new.1", dest = "/usr/share/man/man1/dcr-new.1", mode = "644" },
+    { source = "man/man1/dcr-run.1", dest = "/usr/share/man/man1/dcr-run.1", mode = "644" },
+    { source = "man/man1/dcr-setup.1", dest = "/usr/share/man/man1/dcr-setup.1", mode = "644" },
+    { source = "man/man1/dcr-test.1", dest = "/usr/share/man/man1/dcr-test.1", mode = "644" },
+    { source = "man/man1/dcr-tree.1", dest = "/usr/share/man/man1/dcr-tree.1", mode = "644" },
 ]
 
+[features]
+default = []
+archive = ["dep:fatfs"]
+
 [dependencies]
 glob = "0.3"
-reqwest = { version = "0.12", default-features = false, features = ["blocking", "json", "rustls-tls"] }
+ureq = { version = "2.10", default-features = false, features = ["json", "native-certs"] }
 serde = { version = "1", features = ["derive"] }
 self-replace = "1"
 sha2 = "0.10"
 toml = "1.0.3"
+toml_edit = "0.22"
 serde_json = "1"
 ctrlc = "3"
+fatfs = { version = "0.3", optional = true }
 
-[target.'cfg(not(windows))'.dependencies]
+[profile.release]
-git2 = { version = "0.20.4", features = ["vendored-libgit2", "vendored-openssl"] }
+opt-level = "z"
-openssl = { version = "0.10", features = ["vendored"] }
+lto = "thin"
+codegen-units = 1
+panic = "abort"
+strip = true
 
-[target.'cfg(windows)'.dependencies]
+[profile.fast]
-git2 = { version = "0.20.4", features = ["vendored-libgit2"] }
+inherits = "release"
+opt-level = 1
+lto = false
+codegen-units = 16
+panic = "abort"
+strip = true
+
+[profile.dev]
+incremental = false
+opt-level = 0
+debug = "line-tables-only"
+
+[profile.dev.package."*"]
+opt-level = 1
+debug = false

FAQ.md

@@ -61,8 +61,19 @@ Available installation methods may vary by project version.
 Recommended path:
 
 - check instructions in `README.md`;
+- use `dcrup install stable` (default mirror chain: **cf → gh → sf → ya**);
+- pin a host with `--mirror cf|gh|sf|ya` or `DCRUP_MIRROR` if needed;
 - if there is no prebuilt package for your platform, build from source using `cargo build --release`.
 
+## How do I choose a download mirror?
+
+`dcrup` defaults to `--mirror auto`: CloudFlare CDN, then GitHub, then SourceForge, then Yandex CDN.
+
+```sh
+dcrup install stable --mirror cf
+export DCRUP_MIRROR=ya
+```
+
 ## How can I get started quickly?
 
 Minimal workflow:

README.md

@@ -1,31 +1,32 @@
-<div align="center">
+<h1 align="center">DCR — Dexoron Cargo Realization</h1>
 
-# DCR — Dexoron Cargo Realization
+<p align="center"><strong>A Cargo-style build tool for C/C++ projects</strong></p>
 
-**A Cargo-style build tool for C/C++ projects**
+<p align="center">
+  <a href="https://github.com/dexoron/dcr/actions/workflows/ci.yml"><img alt="CI" src="https://github.com/dexoron/dcr/actions/workflows/ci.yml/badge.svg"></a>
+  <a href="https://github.com/dexoron/dcr/releases/latest"><img alt="GitHub Release" src="https://img.shields.io/github/v/release/dexoron/dcr"></a>
+  <a href="https://github.com/dexoron/dcr/releases"><img alt="Platform" src="https://img.shields.io/badge/platform-linux%20%7C%20macos%20%7C%20windows-lightgrey"></a>
+  <br>
+  <a href="https://aur.archlinux.org/packages/dcr"><img alt="AUR" src="https://img.shields.io/aur/version/dcr"></a>
+  <a href="https://crates.io/crates/dcr"><img alt="Crates.io" src="https://img.shields.io/crates/v/dcr"></a>
+  <a href="https://github.com/dexoron/homebrew-dexoron"><img alt="Homebrew" src="https://img.shields.io/badge/homebrew-dexoron%2Fdexoron-orange"></a>
+  <br>
+  <a href="https://github.com/dexoron/dcr/stargazers"><img alt="GitHub Stars" src="https://img.shields.io/github/stars/dexoron/dcr?style=flat"></a>
+  <a href="LICENSE"><img alt="License: GPL-3.0" src="https://img.shields.io/badge/License-GPL--3.0-blue.svg"></a>
+</p>
 
-[![CI](https://github.com/dexoron/dcr/actions/workflows/ci.yml/badge.svg)](https://github.com/dexoron/dcr/actions/workflows/ci.yml)
+<!-- Snap badge removed: classic confinement was denied for this project. -->
-[![GitHub Release](https://img.shields.io/github/v/release/dexoron/dcr)](https://github.com/dexoron/dcr/releases/latest)
-[![Platform](https://img.shields.io/badge/platform-linux%20%7C%20macos%20%7C%20windows-lightgrey)](https://github.com/dexoron/dcr/releases)
-<br/>
-[![AUR](https://img.shields.io/aur/version/dcr)](https://aur.archlinux.org/packages/dcr)
-[![Crates.io](https://img.shields.io/crates/v/dcr)](https://crates.io/crates/dcr)
-[![Homebrew](https://img.shields.io/badge/homebrew-dexoron%2Fdexoron-orange)](https://github.com/dexoron/homebrew-dexoron)
-<br/>
-[![GitHub Stars](https://img.shields.io/github/stars/dexoron/dcr?style=flat)](https://github.com/dexoron/dcr/stargazers)
-[![License: GPL-3.0](https://img.shields.io/badge/License-GPL--3.0-blue.svg)](LICENSE)
-
-</div>
 
 ---
 
 ## Why DCR?
 
 - **No boilerplate** — one config file, predictable structure
-- **Cargo-like workflow** — `build`, `run`, `clean`, `test`, `add`
+- **Cargo-like workflow** — `build`, `run`, `clean`, `test`, `add`, `fmt`
 - **Cross-compilation** — full target triple support with short names
 - **IDE integration** — VS Code, CLion, `compile_commands.json` out of the box
 - **Dependencies** — path, git, and registry-based with lock file
+- **Man pages** — `man dcr` and per-command pages (`man dcr-build`, `man dcr-new`, etc.)
 
 ---
 
@@ -33,38 +34,15 @@
 
 <table>
 <tr>
-<td><b>Linux (Dexoron Packages)</b></td>
-<td>
-
-See https://dcr.dexoron.su for settings youre packages manager
-
-**Arch Linux:**
-
-```sh
-sudo pacman -Sy dcr
-```
-
-**Debian/Ubuntu:**
-
-```sh
-sudo apt update && sudo apt install dcr
-```
-
-**Fedora/RHEL:**
-
-```sh
-sudo dnf install dcr
-```
-
-</td>
-</tr>
-<tr>
 <td><b>Arch Linux (AUR)</b></td>
 <td>
 
 ```sh
 yay -S dcr
+# or
+paru -S dcr
 ```
+> 💡 Do you like DCR? Vote for the package on the [AUR](https://aur.archlinux.org/packages/dcr) page—it will help the project get into the official "extra" repository!
 
 </td>
 </tr>
@@ -102,31 +80,45 @@ cargo install dcr
 </td>
 </tr>
 <tr>
-<td><b>Linux / macOS (script)</b></td>
+<td><b>dcrup (Linux / macOS / BSD / Windows(Bash))</b></td>
 <td>
 
 ```sh
-curl -fsSL https://dcr.dexoron.su/install.sh | bash
+curl -fsSL https://sh.dcr-tool.ru | sh -s -- self-install
+export PATH="$HOME/.dcr/bin:$PATH"
+dcrup install stable                 # auto: cf → gh → sf → ya
+# dcrup install stable --mirror cf   # CloudFlare CDN
+# dcrup install stable --mirror ya   # Yandex CDN (RU)
 ```
 
 </td>
 </tr>
 <tr>
-<td><b>BSD (script)</b></td>
+<td><b>dcrup (Windows PowerShell)</b></td>
-<td>
-
-```sh
-curl -fsSL https://dcr.dexoron.su/install_bsd.sh | bash
-```
-
-</td>
-</tr>
-<tr>
-<td><b>Windows (PowerShell)</b></td>
 <td>
 
 ```powershell
-irm https://dcr.dexoron.su/install.ps1 | iex
+irm https://ps1.dcr-tool.ru | iex
+# or:
+# irm https://ps1.dcr-tool.ru -OutFile dcrup.ps1
+# powershell -File .\dcrup.ps1 self-install
+# $env:Path += ";$env:USERPROFILE\.dcr\bin"
+dcrup install stable                 # auto: cf → gh → sf → ya
+# dcrup install stable --mirror cf   # CloudFlare CDN
+# dcrup install stable --mirror ya   # Yandex CDN (RU)
+```
+
+</td>
+</tr>
+<tr>
+<td><b>Snap (Linux)</b></td>
+<td>
+
+> Snap Store publishing temporarily disabled — see [#51671](https://forum.snapcraft.io/t/classic-confinement-request-for-dcrup/51671).
+> Download the `.snap` from [GitHub Releases](https://github.com/dexoron/dcr/releases/latest) and install manually:
+
+```sh
+sudo snap install --classic --dangerous dcrup_*.snap
 ```
 
 </td>
@@ -137,7 +129,7 @@ irm https://dcr.dexoron.su/install.ps1 | iex
 
 ```sh
 git clone https://github.com/dexoron/dcr.git
-cd dcr && cargo build --release
+cd dcr && cargo build --release --features archive
 ln -sf "$PWD/target/release/dcr" ~/.local/bin/dcr
 ```
 
@@ -200,24 +192,26 @@ kind = "bin"
 | `dcr gen <vscode\|clion\|compile-commands>` | Generate IDE integration |
 | `dcr setup` | Initialize DCR registry |
 
-other in [docs/](docs/) and `dcr --help`
+other in [docs/](docs/), `dcr --help` and `dcr <command> --help`
 
 ---
 
-## Platforms(pre-build source)
+## Platforms (pre-built binary)
 
 <div align="center">
 
-| OS | x86_64 | aarch64 | armv7 | i686 | riscv64 | GNU | Musl | MSVC | MinGW |
+| OS | x86_64 | aarch64 | armv7 | i686 | riscv64 |
-|:---:|:---:|:---:|:---:|:---:|:---:|:---:|:---:|:---:|:---:|
+|:---:|:---:|:---:|:---:|:---:|:---:|
-| Linux   | ✅ | ✅ | ❌ | ❌ | ❌ | ✅ | ✅ | ❌ | ❌ |
+| Linux (GNU)     | ✅ | ✅ | ✅ | ✅ | ✅ |
-| macOS   | ✅ | ✅ | ❌ | ❌ | ❌ | ❌ | ❌ | ❌ | ❌ |
+| Linux (Musl)    | ✅ | ✅ | ✅ | ✅ | 🚧 |
-| Windows | ✅ | ✅ | ❌ | ❌ | ❌ | ❌ | ❌ | ✅ | ✅ |
+| macOS           | ✅ | ✅ | ❌ | ❌ | ❌ |
-| FreeBSD | ✅ | ❌ | ❌ | ❌ | ❌ | ✅ | ❌ | ❌ | ❌ |
+| Windows (MSVC)  | ✅ | ✅ | ❌ | ✅ | ❌ |
-| OpenBSD | ✅ | ❌ | ❌ | ❌ | ❌ | ✅ | ❌ | ❌ | ❌ |
+| Windows (MinGW) | ✅ | 🚧 | ❌ | ❌ | ❌ |
-| NetBSD  | ✅ | ❌ | ❌ | ❌ | ❌ | ✅ | ❌ | ❌ | ❌ |
+| FreeBSD         | ✅ | 🚧 | ❌ | ❌ | ❌ |
+| OpenBSD         | ✅ | 🚧 | ❌ | ❌ | ❌ |
+| NetBSD          | ✅ | 🚧 | ❌ | ❌ | ❌ |
 
-✅ officially supported · ⚠️ community / best-effort · ❌ not supported
+✅ pre-built binary · 🚧 planned · ❌ not supported by platform or CI
 
 </div>
 
@@ -229,6 +223,41 @@ Full docs at **[dcr.dexoron.su](https://dcr.dexoron.su)** or in the [`docs/`](do
 
 ---
 
+## Repository Mirrors
+
+The primary repository is hosted on GitHub. Source and release mirrors:
+
+| Region | Mirror | Contents |
+|---|---|---|
+| Worldwide | [GitHub](https://github.com/dexoron/dcr) | Source code and releases |
+| Worldwide | [SourceForge](https://sourceforge.net/projects/dcr-tool/) | Source code and releases |
+| Russia | [GitVerse](https://gitverse.ru/dcr_labs/dcr) | Source code |
+| Russia | [SourceCraft](https://sourcecraft.dev/dexoron-dev/dcr) | Source code |
+
+Release CDN (used by `dcrup`):
+
+| Code | Host | Role |
+|---|---|---|
+| `cf` | [cdn-global.dcr-tool.ru](https://cdn-global.dcr-tool.ru) (CloudFlare) | Worldwide CDN |
+| `gh` | GitHub Releases | Primary host |
+| `sf` | SourceForge | Worldwide fallback |
+| `ya` | [cdn-ru.dcr-tool.ru](https://cdn-ru.dcr-tool.ru) (Yandex) | Paid RU fallback for restrictions |
+
+`dcrup install` defaults to `--mirror auto` and tries **cf → gh → sf → ya**. Override with `--mirror cf|gh|sf|ya` or `DCRUP_MIRROR`.
+
+---
+
+## VS Code Extension
+
+Install the recommended [DCR extension by Dexoron-Labs](https://marketplace.visualstudio.com/items?itemName=Dexoron-Labs.dcr) for VS Code. Do not install Microsoft C/C++ extensions for DCR projects; DCR uses `clangd` instead. If you need debugging with Microsoft's debugger, use MS C/C++ only for its debugger component.
+
+Recommended companion extensions:
+
+- [Even Better TOML](https://marketplace.visualstudio.com/items?itemName=tamasfe.even-better-toml)
+- [CodeLLDB](https://marketplace.visualstudio.com/items?itemName=vadimcn.vscode-lldb), or MS C/C++ for debugger support only
+
+---
+
 ## Contributors
 
 <div align="center">
@@ -257,6 +286,7 @@ cargo test
 <div align="center">
 
 GPL-3.0 — see [LICENSE](LICENSE)<br/>
+DCR is a build tool, not a library. The GPL applies only to DCR's own source code, not to projects built with it.<br/>
 Made with ❤️ by [Dexoron](https://github.com/dexoron) and contributors.
 
-</div>
+</div>

TODO.md

@@ -1,69 +0,0 @@
-# DCR TODO.md
-
-Priority list of tasks to turn DCR into a true Cargo killer for C/C++ developers.
-
-## 🔥 High Priority (Next Releases)
-
-- [x] **Git dependencies support**  
-  `git = "https://github.com/user/repo.git#branch"` and `git = "..."@tag`
-- [ ] **Conan and vcpkg integration**  
-  Automatic download, installation and linking of packages
-- [ ] **Full freestanding / embedded support**  
-  `-nostdlib`, linker scripts, bare-metal targets (i686-elf, aarch64-none-elf, etc.)
-- [ ] **EFI support**  
-  Dedicated platform configuration for EFI targets
-- [ ] **Custom project name**  
-  Override binary name in `dcr.toml`
-- [ ] **Custom build steps / targets**  
-  Ability to define custom pre-build, post-build, codegen steps in `dcr.toml`
-- [ ] **Improved mixed C/C++/ASM projects**  
-  Better handling of `.S` and `.asm` files with correct flags
-- [ ] **dcr publish + official package registry**  
-  Publish and fetch your own libraries easily
-
-## ✅ Medium Priority
-
-- [ ] **Static analysis** (`dcr check`)  
-  Integration with clang-tidy, cppcheck, include-what-you-use
-- [ ] **Linter + Formatter** (`dcr fmt`, `dcr lint`)
-- [ ] **Hot reload / Live reload** for applications (raylib, SFML, SDL, etc.)
-- [ ] **Better cross-compilation experience**  
-  Ready-to-use toolchains + automatic download
-- [ ] **Linker script support** + direct linker control
-- [ ] **Workspaces improvements**  
-  Per-member include directories, selective builds, better dependency graph
-- [ ] **Build-time code generation**  
-  Support for protobuf, flatbuffers, Qt moc, custom generators
-
-## 📌 Low Priority / Nice to Have
-
-- [ ] Support for Meson and Ninja as alternative backends
-- [ ] Dockerfile generation (`dcr docker init`)
-- [ ] First-class Windows MSVC support (currently works but rough)
-- [ ] Documentation generation (`dcr doc`)
-- [ ] Sanitizers integration (`dcr sanitize`)
-- [ ] Benchmarks and comparison with CMake/Meson
-- [ ] C++20 modules support (when it becomes stable)
-
-## 🧠 Future Ideas
-
-- Official DCR package registry (dcrhub)
-- GUI wrapper (dcr-gui)
-- Plugin system
-- Toolchain manager (like rustup)
-- Zig as alternative compiler
-- deb/rpm/flatpak/AppImage packaging support
-
----
-
-**Currently in progress:**
-
-- ...
-
-**Completed in recent releases:**
-
-- Workspaces
-- Cross-compilation
-- IDE config generation (VS Code, CLion, compile_commands.json)
-- Self-update (`dcr --update`)
-- Header tracking

build.rs

@@ -18,4 +18,37 @@
 fn main() {
     let target = std::env::var("TARGET").unwrap_or_else(|_| "unknown-target".to_string());
     println!("cargo:rustc-env=DCR_TARGET={target}");
+
+    // Let's try to retrieve the commit hash for the version
+    let commit = std::process::Command::new("git")
+        .args(["rev-parse", "--short", "HEAD"])
+        .output()
+        .ok()
+        .and_then(|o| {
+            if o.status.success() {
+                String::from_utf8(o.stdout)
+                    .ok()
+                    .map(|s| s.trim().to_string())
+            } else {
+                None
+            }
+        });
+
+    // Check if there are any uncommitted changes in the repository
+    let is_dirty = std::process::Command::new("git")
+        .args(["status", "--porcelain"])
+        .output()
+        .ok()
+        .map(|o| o.status.success() && !o.stdout.is_empty())
+        .unwrap_or(false);
+
+    if let Some(commit_hash) = commit {
+        let dirty_suffix = if is_dirty { "-dirty" } else { "" };
+        println!(
+            "cargo:rustc-env=DCR_GIT_INFO= (git {}{})",
+            commit_hash, dirty_suffix
+        );
+    } else {
+        println!("cargo:rustc-env=DCR_GIT_INFO=");
+    }
 }

crowdin.yml

@@ -0,0 +1,3 @@
+files:
+  - source: /docs/**/*.mdx
+    translation: /docs-crowdin-export/%locale%/%original_path%/%original_file_name%.%file_extension%

dcrup.cmd

@@ -0,0 +1,13 @@
+@echo off
+setlocal
+set "SCRIPT_DIR=%~dp0"
+if exist "%SCRIPT_DIR%dcrup.ps1" (
+  powershell -NoProfile -ExecutionPolicy Bypass -File "%SCRIPT_DIR%dcrup.ps1" %*
+  exit /b %ERRORLEVEL%
+)
+if exist "%USERPROFILE%\.dcr\bin\dcrup.ps1" (
+  powershell -NoProfile -ExecutionPolicy Bypass -File "%USERPROFILE%\.dcr\bin\dcrup.ps1" %*
+  exit /b %ERRORLEVEL%
+)
+echo [error] dcrup.ps1 not found near dcrup.cmd >&2
+exit /b 1

dcrup.ps1

@@ -0,0 +1,434 @@
+#Requires -Version 5.1
+$ErrorActionPreference = 'Stop'
+
+$DcrupHome = if ($env:DCRUP_HOME) { $env:DCRUP_HOME } else { Join-Path $env:USERPROFILE '.dcr' }
+$DcrupBin  = if ($env:DCRUP_BIN)  { $env:DCRUP_BIN  } else { Join-Path $DcrupHome 'bin' }
+$DcrupTc   = Join-Path $DcrupHome 'toolchains'
+$DcrupMeta = Join-Path $DcrupHome 'meta'
+$RepoUrl   = if ($env:DCRUP_REPO) { $env:DCRUP_REPO } else { 'https://github.com/dexoron/dcr' }
+$DcrupMirror = if ($env:DCRUP_MIRROR) { $env:DCRUP_MIRROR } else { 'auto' }
+$ApiLatest = 'https://api.github.com/repos/dexoron/dcr/releases/latest'
+$ApiAll    = 'https://api.github.com/repos/dexoron/dcr/releases'
+$Features  = if ($env:DCR_FEATURES) { $env:DCR_FEATURES } else { 'archive' }
+
+function Info($m) { Write-Host "[dcrup] $m" -ForegroundColor Cyan }
+function Ok($m)   { Write-Host "[ok] $m" -ForegroundColor Green }
+function Warn($m) { Write-Host "[warn] $m" -ForegroundColor Yellow }
+function Die($m)  { Write-Host "[error] $m" -ForegroundColor Red; exit 1 }
+
+function Show-Usage {
+    @'
+dcrup — install and switch DCR versions (Windows)
+
+Usage:
+  dcrup install <spec> [--build|--release] [--force] [--mirror auto|cf|gh|sf|ya]
+  dcrup default <spec>
+  dcrup update
+  dcrup list
+  dcrup show
+  dcrup which
+  dcrup uninstall [<spec>|--all]
+  dcrup self-install [--to DIR]
+  dcrup help
+
+Spec:
+  stable | dev | night
+  VERSION              → VERSION@stable  (e.g. 0.8.2)
+  VERSION@stable
+  VERSION@dev
+  night                → always build from branch "dev" HEAD
+
+Modes:
+  --release   download prebuilt binary (default for stable/dev)
+  --build     cargo build --release --features archive
+  night       always --build (prebuilt not available)
+
+Mirrors (prebuilt download only):
+  --mirror auto   try cf → gh → sf → ya, first successful download wins (default)
+  --mirror cf     download from cdn-global.dcr-tool.ru
+  --mirror gh     download from github.com/dexoron/dcr
+  --mirror sf     download from sourceforge.net/projects/dcr-tool
+  --mirror ya     download from cdn-ru.dcr-tool.ru
+  DCRUP_MIRROR    env override (default: auto)
+
+Env:
+  DCRUP_HOME      default ~/.dcr
+  DCRUP_BIN       default $DCRUP_HOME/bin
+  DCR_FEATURES    default archive
+  DCRUP_REPO      git/GitHub repo URL
+  DCRUP_MIRROR    auto|cf|gh|sf|ya (default: auto)
+'@ | Write-Host
+}
+
+function Ensure-Dirs {
+    New-Item -ItemType Directory -Force -Path $DcrupTc, $DcrupBin, $DcrupMeta | Out-Null
+}
+
+function Get-Target {
+    $arch = $env:PROCESSOR_ARCHITECTURE
+    if ($env:PROCESSOR_ARCHITEW6432) { $arch = $env:PROCESSOR_ARCHITEW6432 }
+    switch ($arch) {
+        'AMD64' { return 'x86_64-pc-windows-msvc' }
+        'ARM64' { return 'aarch64-pc-windows-msvc' }
+        'x86'   { return 'i686-pc-windows-msvc' }
+        default { Die "unsupported arch: $arch" }
+    }
+}
+
+function Normalize-Version([string]$v) {
+    if ($v.StartsWith('v')) { return $v.Substring(1) }
+    return $v
+}
+
+function Parse-Spec([string]$raw) {
+    $script:SpecRaw = $raw
+    $script:SpecChannel = $null
+    $script:SpecVersion = $null
+    $script:SpecFloating = $false
+
+    if ($raw -in @('stable', 'dev', 'night')) {
+        $script:SpecChannel = $raw
+        $script:SpecFloating = $true
+        return
+    }
+    if ($raw -match '^(.*)@(.*)$') {
+        $script:SpecVersion = Normalize-Version $Matches[1]
+        $script:SpecChannel = $Matches[2]
+        if ($script:SpecChannel -eq 'night') { Die 'cannot pin version on night' }
+        if ($script:SpecChannel -notin @('stable', 'dev')) { Die "unknown channel: $($script:SpecChannel)" }
+        return
+    }
+    $script:SpecVersion = Normalize-Version $raw
+    $script:SpecChannel = 'stable'
+}
+
+function Toolchain-Id([string]$extra = '') {
+    if ($script:SpecChannel -eq 'night') {
+        return "night-$extra"
+    }
+    if ($script:SpecFloating) {
+        return "$($script:SpecChannel)-$extra"
+    }
+    return "$($script:SpecVersion)-$($script:SpecChannel)"
+}
+
+function Active-Path { Join-Path $DcrupMeta 'active' }
+
+function Read-Active {
+    $p = Active-Path
+    if (Test-Path $p) { return (Get-Content $p -Raw).Trim() }
+    return $null
+}
+
+function Write-Active([string]$id) {
+    Set-Content -Path (Active-Path) -Value $id -NoNewline
+}
+
+function Link-Default([string]$id) {
+    $src = Join-Path (Join-Path $DcrupTc $id) 'dcr.exe'
+    if (-not (Test-Path $src)) { Die "toolchain not installed: $id" }
+    $dst = Join-Path $DcrupBin 'dcr.exe'
+    Copy-Item $src $dst -Force
+    Write-Active $id
+    Ok "default → $id ($dst)"
+}
+
+function Set-Mirror([string]$value) {
+    if ($value -notin @('auto', 'cf', 'gh', 'sf', 'ya')) {
+        Die "invalid --mirror: $value (use auto|cf|gh|sf|ya)"
+    }
+    $script:DcrupMirror = $value
+}
+
+function Get-MirrorUrl([string]$mirror, [string]$tag, [string]$asset) {
+    switch ($mirror) {
+        'cf' { return "https://cdn-global.dcr-tool.ru/$tag/$asset" }
+        'gh' { return "https://github.com/dexoron/dcr/releases/download/$tag/$asset" }
+        'sf' { return "https://sourceforge.net/projects/dcr-tool/files/$tag/$asset/download" }
+        'ya' { return "https://cdn-ru.dcr-tool.ru/$tag/$asset" }
+        default { Die "invalid mirror: $mirror" }
+    }
+}
+
+function Get-MirrorsToTry {
+    switch ($script:DcrupMirror) {
+        'auto' { return @('cf', 'gh', 'sf', 'ya') }
+        { $_ -in @('cf', 'gh', 'sf', 'ya') } { return @($script:DcrupMirror) }
+        default { Die "invalid mirror: $($script:DcrupMirror) (use auto|cf|gh|sf|ya)" }
+    }
+}
+
+function Download-FromMirrors([string]$tag, [string]$asset, [string]$destFile) {
+    $tmp = "$destFile.download"
+    foreach ($m in (Get-MirrorsToTry)) {
+        $url = Get-MirrorUrl $m $tag $asset
+        Info "trying mirror $m …"
+        Remove-Item $tmp -ErrorAction SilentlyContinue
+        try {
+            Invoke-WebRequest -Uri $url -OutFile $tmp -UserAgent 'dcrup'
+            $size = (Get-Item $tmp).Length
+            if ($size -gt 100000) {
+                Move-Item $tmp $destFile -Force
+                return $m
+            }
+            Warn "mirror $m returned a too-small file ($size bytes)"
+        } catch {
+            Warn "mirror $m failed"
+        }
+        Remove-Item $tmp -ErrorAction SilentlyContinue
+    }
+    return $null
+}
+
+function Fetch-Release($channel, $version) {
+    if ($version) {
+        return Invoke-RestMethod -Uri "https://api.github.com/repos/dexoron/dcr/releases/tags/v$version"
+    }
+    if ($channel -eq 'dev') {
+        $all = Invoke-RestMethod -Uri $ApiAll
+        $pre = $all | Where-Object { $_.prerelease } | Select-Object -First 1
+        if (-not $pre) { Die 'no prerelease (dev) found' }
+        return $pre
+    }
+    return Invoke-RestMethod -Uri $ApiLatest
+}
+
+function Install-Prebuilt([switch]$Force) {
+    $triple = Get-Target
+    $rel = Fetch-Release $script:SpecChannel $script:SpecVersion
+    $tag = $rel.tag_name
+    $ver = Normalize-Version $tag
+    $assetName = "dcr-$triple-$ver.exe"
+
+    $id = if ($script:SpecFloating) { Toolchain-Id $ver } else { Toolchain-Id }
+    $dest = Join-Path $DcrupTc $id
+    $bin = Join-Path $dest 'dcr.exe'
+    if ((Test-Path $bin) -and -not $Force) {
+        Ok "already installed: $id"
+        Link-Default $id
+        return
+    }
+    Ensure-Dirs
+    New-Item -ItemType Directory -Force -Path $dest | Out-Null
+    Info "downloading $assetName (mirror=$($script:DcrupMirror)) …"
+    $mirror = Download-FromMirrors $tag $assetName $bin
+    if (-not $mirror) { Die "no mirror reachable for $assetName (try: --mirror cf|gh|sf|ya)" }
+    Info "mirror → $mirror"
+    @"
+channel=$($script:SpecChannel)
+version=$ver
+tag=$tag
+source=release
+triple=$triple
+mirror=$mirror
+"@ | Set-Content (Join-Path $dest 'dcrup-meta')
+    Ok "installed prebuilt $id ($triple via $mirror)"
+    Link-Default $id
+}
+
+function Install-Build([switch]$Force) {
+    if (-not (Get-Command git -ErrorAction SilentlyContinue)) { Die 'git not found' }
+    if (-not (Get-Command cargo -ErrorAction SilentlyContinue)) { Die 'cargo not found' }
+
+    $tmp = Join-Path $env:TEMP ("dcrup-" + [guid]::NewGuid().ToString('N'))
+    New-Item -ItemType Directory -Path $tmp | Out-Null
+    try {
+        $src = Join-Path $tmp 'src'
+        if ($script:SpecChannel -eq 'night') {
+            Info "cloning dev for night …"
+            git clone --depth 1 --branch dev $RepoUrl $src 2>$null
+            if ($LASTEXITCODE -ne 0) { git clone --depth 1 $RepoUrl $src | Out-Null }
+            $sha = (git -C $src rev-parse --short HEAD).Trim()
+            $id = Toolchain-Id $sha
+            $ver = 'night'
+        } elseif ($script:SpecFloating) {
+            $rel = Fetch-Release $script:SpecChannel $null
+            $tag = $rel.tag_name
+            $ver = Normalize-Version $tag
+            $id = Toolchain-Id $ver
+            Info "cloning $tag …"
+            git clone --depth 1 --branch $tag $RepoUrl $src 2>$null
+            if ($LASTEXITCODE -ne 0) {
+                git clone --depth 1 $RepoUrl $src | Out-Null
+                git -C $src fetch --depth 1 origin "refs/tags/${tag}:refs/tags/${tag}"
+                git -C $src checkout $tag
+            }
+            $sha = (git -C $src rev-parse --short HEAD).Trim()
+        } else {
+            $tag = "v$($script:SpecVersion)"
+            $ver = $script:SpecVersion
+            $id = Toolchain-Id
+            Info "cloning $tag …"
+            git clone --depth 1 --branch $tag $RepoUrl $src 2>$null
+            if ($LASTEXITCODE -ne 0) {
+                git clone --depth 1 $RepoUrl $src | Out-Null
+                git -C $src fetch --depth 1 origin "refs/tags/${tag}:refs/tags/${tag}"
+                git -C $src checkout $tag
+            }
+            $sha = (git -C $src rev-parse --short HEAD).Trim()
+        }
+
+        $dest = Join-Path $DcrupTc $id
+        $bin = Join-Path $dest 'dcr.exe'
+        if ((Test-Path $bin) -and -not $Force) {
+            Ok "already installed: $id"
+            Link-Default $id
+            return
+        }
+
+        $triple = Get-Target
+        Info "building release (features: $Features) …"
+        Push-Location $src
+        cargo build --release --features $Features --target $triple
+        if ($LASTEXITCODE -ne 0) { Die 'cargo build failed' }
+        Pop-Location
+
+        New-Item -ItemType Directory -Force -Path $dest | Out-Null
+        Copy-Item (Join-Path $src "target\$triple\release\dcr.exe") $bin -Force
+        @"
+channel=$($script:SpecChannel)
+version=$ver
+git=$sha
+source=build
+features=$Features
+"@ | Set-Content (Join-Path $dest 'dcrup-meta')
+        Ok "installed build $id"
+        Link-Default $id
+    } finally {
+        Remove-Item -Recurse -Force $tmp -ErrorAction SilentlyContinue
+    }
+}
+
+function Ensure-UserPath {
+    $userPath = [Environment]::GetEnvironmentVariable('Path', 'User')
+    if (-not $userPath) { $userPath = '' }
+    if (-not ($userPath -split ';' | Where-Object { $_ -eq $DcrupBin })) {
+        $new = if ($userPath) { "$userPath;$DcrupBin" } else { $DcrupBin }
+        [Environment]::SetEnvironmentVariable('Path', $new, 'User')
+        $env:Path = "$env:Path;$DcrupBin"
+        Warn "added to user PATH: $DcrupBin (restart shell if needed)"
+    }
+}
+
+function Install-CmdShim {
+    $cmd = Join-Path $DcrupBin 'dcrup.cmd'
+    $ps1 = Join-Path $DcrupBin 'dcrup.ps1'
+    @"
+@echo off
+setlocal
+powershell -NoProfile -ExecutionPolicy Bypass -File "%~dp0dcrup.ps1" %*
+"@ | Set-Content -Path $cmd -Encoding ASCII
+    if (-not (Test-Path $ps1)) {
+        Copy-Item $PSCommandPath $ps1 -Force
+    }
+}
+
+function Cmd-Install {
+    param([string[]]$Args)
+    $mode = 'release'
+    $force = $false
+    $spec = $null
+    $i = 0
+    while ($i -lt $Args.Count) {
+        $a = $Args[$i]
+        switch -Regex ($a) {
+            '^--build$' { $mode = 'build' }
+            '^--release$' { $mode = 'release' }
+            '^--force$' { $force = $true }
+            '^--mirror$' {
+                if ($i + 1 -ge $Args.Count) { Die '--mirror needs auto|cf|gh|sf|ya' }
+                $i++
+                Set-Mirror $Args[$i]
+            }
+            '^--mirror=(.+)$' { Set-Mirror $Matches[1] }
+            '^-' { Die "unknown flag: $a" }
+            default {
+                if ($spec) { Die "unexpected: $a" }
+                $spec = $a
+            }
+        }
+        $i++
+    }
+    if (-not $spec) { Die 'usage: dcrup install <spec> [--build|--release] [--force] [--mirror auto|cf|gh|sf|ya]' }
+    Parse-Spec $spec
+    Ensure-Dirs
+    if ($script:SpecChannel -eq 'night') { $mode = 'build' }
+    Info "install spec=$spec channel=$($script:SpecChannel) mode=$mode mirror=$($script:DcrupMirror)"
+    if ($mode -eq 'build') { Install-Build -Force:$force } else { Install-Prebuilt -Force:$force }
+    Ensure-UserPath
+    Install-CmdShim
+}
+
+function Cmd-List {
+    Ensure-Dirs
+    $active = Read-Active
+    Get-ChildItem $DcrupTc -Directory -ErrorAction SilentlyContinue | ForEach-Object {
+        $mark = if ($_.Name -eq $active) { ' *' } else { '  ' }
+        Write-Host "$mark $($_.Name)"
+    }
+}
+
+function Cmd-Show {
+    Ensure-Dirs
+    Write-Host "DCRUP_HOME=$DcrupHome"
+    Write-Host "DCRUP_BIN=$DcrupBin"
+    Write-Host "active=$(Read-Active)"
+    $exe = Join-Path $DcrupBin 'dcr.exe'
+    if (Test-Path $exe) { & $exe --version }
+}
+
+function Cmd-SelfInstall {
+    Ensure-Dirs
+    Copy-Item $PSCommandPath (Join-Path $DcrupBin 'dcrup.ps1') -Force
+    Install-CmdShim
+    Ensure-UserPath
+    Ok "dcrup installed to $DcrupBin (use: dcrup …)"
+}
+
+$cmd = if ($args.Count -ge 1) { $args[0] } else { 'help' }
+$rest = @()
+if ($args.Count -gt 1) { $rest = $args[1..($args.Count - 1)] }
+
+switch ($cmd) {
+    { $_ -in @('help', '-h', '--help') } { Show-Usage }
+    'install' { Cmd-Install $rest }
+    'list' { Cmd-List }
+    'show' { Cmd-Show }
+    'which' {
+        $p = Join-Path $DcrupBin 'dcr.exe'
+        if (Test-Path $p) { $p } else { Die 'dcr not installed' }
+    }
+    'default' {
+        if ($rest.Count -ne 1) { Die 'usage: dcrup default <spec>' }
+        Parse-Spec $rest[0]
+        if ($script:SpecFloating -or $script:SpecChannel -eq 'night') {
+            $id = Get-ChildItem $DcrupTc -Directory |
+                Where-Object { $_.Name -like "$($script:SpecChannel)-*" } |
+                Sort-Object Name | Select-Object -Last 1
+            if (-not $id) { Die "not installed: $($rest[0])" }
+            Link-Default $id.Name
+        } else {
+            Link-Default (Toolchain-Id)
+        }
+    }
+    'update' {
+        $a = Read-Active
+        if (-not $a) { Die 'no active toolchain' }
+        if ($a -like 'night-*') { Cmd-Install @('night', '--build', '--force') }
+        elseif ($a -like 'stable-*') { Cmd-Install @('stable', '--force') }
+        elseif ($a -like 'dev-*') { Cmd-Install @('dev', '--force') }
+        else { Ok "pinned $a — install a newer version explicitly" }
+    }
+    'uninstall' {
+        if ($rest -contains '--all') {
+            Remove-Item -Recurse -Force $DcrupTc -ErrorAction SilentlyContinue
+            Remove-Item (Join-Path $DcrupBin 'dcr.exe') -ErrorAction SilentlyContinue
+            Remove-Item (Active-Path) -ErrorAction SilentlyContinue
+            Ok 'removed all'
+        } else {
+            Die 'use: dcrup uninstall --all  (or install a replacement first)'
+        }
+    }
+    'self-install' { Cmd-SelfInstall }
+    default { Die "unknown command: $cmd" }
+}

dcrup.sh

@@ -0,0 +1,668 @@
+#!/usr/bin/env bash
+set -Eeuo pipefail
+
+DCRUP_HOME="${DCRUP_HOME:-$HOME/.dcr}"
+DCRUP_BIN="${DCRUP_BIN:-$DCRUP_HOME/bin}"
+DCRUP_TC="${DCRUP_HOME}/toolchains"
+DCRUP_META="${DCRUP_HOME}/meta"
+REPO_URL="${DCRUP_REPO:-https://github.com/dexoron/dcr}"
+DCRUP_MIRROR="${DCRUP_MIRROR:-auto}"
+API_LATEST="https://api.github.com/repos/dexoron/dcr/releases/latest"
+API_ALL="https://api.github.com/repos/dexoron/dcr/releases"
+FEATURES="${DCR_FEATURES:-archive}"
+
+RED='\033[0;31m'
+GREEN='\033[0;32m'
+YELLOW='\033[1;33m'
+CYAN='\033[0;36m'
+NC='\033[0m'
+
+log()  { printf "${CYAN}[dcrup]${NC} %s\n" "$*"; }
+ok()   { printf "${GREEN}[ok]${NC} %s\n" "$*"; }
+warn() { printf "${YELLOW}[warn]${NC} %s\n" "$*"; }
+die()  { printf "${RED}[error]${NC} %s\n" "$*" >&2; exit 1; }
+
+usage() {
+    cat <<'EOF'
+dcrup — install and switch DCR versions
+
+Usage:
+  dcrup install <spec> [--build|--release] [--force] [--libc gnu|musl|auto] [--mirror auto|cf|gh|sf|ya]
+  dcrup default <spec>
+  dcrup update
+  dcrup list
+  dcrup show
+  dcrup which
+  dcrup uninstall [<spec>|--all]
+  dcrup self-install [--to DIR]
+  dcrup help
+
+Spec:
+  stable | dev | night
+  VERSION              → VERSION@stable  (e.g. 0.8.2)
+  VERSION@stable
+  VERSION@dev
+  night                → always build from branch "dev" HEAD
+
+Modes:
+  --release   download prebuilt binary (default for stable/dev)
+  --build     cargo build --release --features archive
+  night       always --build (prebuilt not available)
+
+Linux libc (prebuilt triple only):
+  --libc gnu    x86_64-unknown-linux-gnu (default)
+  --libc musl   x86_64-unknown-linux-musl
+  --libc auto   musl if host ldd/libc is musl, else gnu
+
+Mirrors (prebuilt download only):
+  --mirror auto   try cf → gh → sf → ya, first successful download wins (default)
+  --mirror cf     download from cdn-global.dcr-tool.ru
+  --mirror gh     download from github.com/dexoron/dcr
+  --mirror sf     download from sourceforge.net/projects/dcr-tool
+  --mirror ya     download from cdn-ru.dcr-tool.ru
+  DCRUP_MIRROR    env override (default: auto)
+
+Env:
+  DCRUP_HOME      default ~/.dcr
+  DCRUP_BIN       default $DCRUP_HOME/bin
+  DCR_FEATURES    default archive
+  DCRUP_REPO      git/GitHub repo URL
+  DCRUP_LIBC      gnu|musl|auto (default: gnu)
+  DCRUP_MIRROR    auto|cf|gh|sf|ya (default: auto)
+EOF
+}
+
+need_cmd() {
+    command -v "$1" >/dev/null 2>&1 || die "required command not found: $1"
+}
+
+detect_linux_libc() {
+    local pref="${DCRUP_LIBC:-gnu}"
+    case "$pref" in
+        gnu|glibc) echo "gnu" ;;
+        musl) echo "musl" ;;
+        auto)
+            if command -v ldd >/dev/null 2>&1; then
+                if ldd --version 2>&1 | grep -qi musl; then
+                    echo "musl"
+                    return 0
+                fi
+            fi
+            if [[ -e /lib/ld-musl-x86_64.so.1 || -e /lib/ld-musl-aarch64.so.1 ]]; then
+                echo "musl"
+                return 0
+            fi
+            if command -v getconf >/dev/null 2>&1 && getconf GNU_LIBC_VERSION >/dev/null 2>&1; then
+                echo "gnu"
+                return 0
+            fi
+            echo "gnu"
+            ;;
+        *) die "invalid DCRUP_LIBC / --libc: $pref (use gnu|musl|auto)" ;;
+    esac
+}
+
+detect_triple() {
+    local os arch libc
+    os="$(uname -s)"
+    arch="$(uname -m)"
+    case "$os:$arch" in
+        Linux:x86_64)
+            libc="$(detect_linux_libc)"
+            if [[ "$libc" == "musl" ]]; then
+                echo "x86_64-unknown-linux-musl"
+            else
+                echo "x86_64-unknown-linux-gnu"
+            fi
+            ;;
+        Linux:aarch64|Linux:arm64)
+            libc="$(detect_linux_libc)"
+            if [[ "$libc" == "musl" ]]; then
+                echo "aarch64-unknown-linux-musl"
+            else
+                echo "aarch64-unknown-linux-gnu"
+            fi
+            ;;
+        Linux:i686|Linux:i386)
+            libc="$(detect_linux_libc)"
+            if [[ "$libc" == "musl" ]]; then
+                echo "i686-unknown-linux-musl"
+            else
+                echo "i686-unknown-linux-gnu"
+            fi
+            ;;
+        Linux:armv7l|Linux:armv7)
+            libc="$(detect_linux_libc)"
+            if [[ "$libc" == "musl" ]]; then
+                echo "armv7-unknown-linux-musleabihf"
+            else
+                echo "armv7-unknown-linux-gnueabihf"
+            fi
+            ;;
+        Linux:riscv64)
+            libc="$(detect_linux_libc)"
+            if [[ "$libc" == "musl" ]]; then
+                echo "riscv64gc-unknown-linux-musl"
+            else
+                echo "riscv64gc-unknown-linux-gnu"
+            fi
+            ;;
+        Darwin:x86_64)               echo "x86_64-apple-darwin" ;;
+        Darwin:arm64|Darwin:aarch64) echo "aarch64-apple-darwin" ;;
+        FreeBSD:x86_64|FreeBSD:amd64) echo "x86_64-unknown-freebsd" ;;
+        FreeBSD:aarch64|FreeBSD:arm64) echo "aarch64-unknown-freebsd" ;;
+        OpenBSD:x86_64|OpenBSD:amd64) echo "x86_64-unknown-openbsd" ;;
+        NetBSD:x86_64|NetBSD:amd64)  echo "x86_64-unknown-netbsd" ;;
+        MINGW*|MSYS*|CYGWIN*)
+            case "$arch" in
+                x86_64|amd64) echo "x86_64-pc-windows-gnu" ;;
+                aarch64|arm64) echo "aarch64-pc-windows-gnullvm" ;;
+                i686|i386) echo "i686-pc-windows-gnu" ;;
+                *) die "unsupported Windows arch under MSYS: $arch" ;;
+            esac
+            ;;
+        *) die "unsupported platform: $os/$arch" ;;
+    esac
+}
+
+normalize_version() {
+    local v="$1"
+    v="${v#v}"
+    printf '%s' "$v"
+}
+
+parse_spec() {
+    local raw="$1"
+    SPEC_RAW="$raw"
+    SPEC_CHANNEL=""
+    SPEC_VERSION=""
+    SPEC_FLOATING=0
+
+    case "$raw" in
+        "") die "missing version/channel spec" ;;
+        stable|dev|night)
+            SPEC_CHANNEL="$raw"
+            SPEC_VERSION=""
+            SPEC_FLOATING=1
+            ;;
+        *@*)
+            SPEC_VERSION="$(normalize_version "${raw%@*}")"
+            SPEC_CHANNEL="${raw#*@}"
+            case "$SPEC_CHANNEL" in
+                stable|dev) ;;
+                night) die "cannot pin a version on night (use: dcrup install night)" ;;
+                *) die "unknown channel in spec: $SPEC_CHANNEL (use stable|dev)" ;;
+            esac
+            [[ -n "$SPEC_VERSION" ]] || die "empty version in spec: $raw"
+            ;;
+        *)
+            SPEC_VERSION="$(normalize_version "$raw")"
+            SPEC_CHANNEL="stable"
+            [[ -n "$SPEC_VERSION" ]] || die "invalid spec: $raw"
+            ;;
+    esac
+}
+
+toolchain_id() {
+    if [[ "$SPEC_CHANNEL" == "night" ]]; then
+        local sha="${1:-unknown}"
+        echo "night-${sha}"
+    elif [[ "$SPEC_FLOATING" -eq 1 ]]; then
+        local ver="${1:-latest}"
+        echo "${SPEC_CHANNEL}-${ver}"
+    else
+        echo "${SPEC_VERSION}-${SPEC_CHANNEL}"
+    fi
+}
+
+ensure_dirs() {
+    mkdir -p "$DCRUP_TC" "$DCRUP_BIN" "$DCRUP_META"
+}
+
+active_file() { echo "$DCRUP_META/active"; }
+
+read_active() {
+    if [[ -f "$(active_file)" ]]; then
+        cat "$(active_file)"
+    fi
+}
+
+write_active() {
+    printf '%s\n' "$1" >"$(active_file)"
+}
+
+link_default() {
+    local id="$1"
+    local src="$DCRUP_TC/$id/dcr"
+    [[ -x "$src" ]] || die "toolchain not installed: $id"
+    ln -sfn "$src" "$DCRUP_BIN/dcr"
+    write_active "$id"
+    ok "default → $id ($DCRUP_BIN/dcr)"
+}
+
+fetch_json() {
+    need_cmd curl
+    curl -fsSL "$1"
+}
+
+json_tag() {
+    printf '%s' "$1" | sed -n 's/.*"tag_name"[[:space:]]*:[[:space:]]*"\([^"]*\)".*/\1/p' | head -n1
+}
+
+set_mirror() {
+    case "$1" in
+        auto|cf|gh|sf|ya) DCRUP_MIRROR="$1" ;;
+        *) die "invalid --mirror: $1 (use auto|cf|gh|sf|ya)" ;;
+    esac
+}
+
+mirror_url() {
+    local mirror="$1" tag="$2" asset="$3"
+    case "$mirror" in
+        cf) printf 'https://cdn-global.dcr-tool.ru/%s/%s' "$tag" "$asset" ;;
+        gh) printf 'https://github.com/dexoron/dcr/releases/download/%s/%s' "$tag" "$asset" ;;
+        sf) printf 'https://sourceforge.net/projects/dcr-tool/files/%s/%s/download' "$tag" "$asset" ;;
+        ya) printf 'https://cdn-ru.dcr-tool.ru/%s/%s' "$tag" "$asset" ;;
+        *) return 1 ;;
+    esac
+}
+
+mirror_chain() { echo "cf gh sf ya"; }
+
+mirrors_to_try() {
+    case "$DCRUP_MIRROR" in
+        auto) mirror_chain ;;
+        cf|gh|sf|ya) echo "$DCRUP_MIRROR" ;;
+        *) die "invalid mirror: $DCRUP_MIRROR (use auto|cf|gh|sf|ya)" ;;
+    esac
+}
+
+download_from_mirrors() {
+    local tag="$1" asset="$2" dest="$3"
+    local tmp="$dest/dcr.download" m url size
+    USED_MIRROR=""
+    for m in $(mirrors_to_try); do
+        url="$(mirror_url "$m" "$tag" "$asset")"
+        log "trying mirror $m …"
+        rm -f "$tmp"
+        if curl -fL --retry 2 --retry-delay 1 --connect-timeout 10 --max-time 180 \
+            -A "dcrup" "$url" -o "$tmp"; then
+            size="$(wc -c <"$tmp" | tr -d ' ')"
+            if [[ "${size:-0}" -gt 100000 ]]; then
+                mv "$tmp" "$dest/dcr"
+                USED_MIRROR="$m"
+                return 0
+            fi
+            warn "mirror $m returned a too-small file (${size:-0} bytes)"
+        else
+            warn "mirror $m failed"
+        fi
+        rm -f "$tmp"
+    done
+    return 1
+}
+
+latest_stable_json() {
+    fetch_json "$API_LATEST"
+}
+
+latest_dev_json() {
+    need_cmd curl
+    local json result
+    json="$(fetch_json "$API_ALL")"
+    if command -v jq >/dev/null 2>&1; then
+        result="$(printf '%s' "$json" | jq -e -c '[.[] | select(.prerelease == true)][0]')" || true
+    elif command -v python3 >/dev/null 2>&1; then
+        result="$(printf '%s' "$json" | python3 -c '
+import sys, json
+rels = json.load(sys.stdin)
+pre = [r for r in rels if r.get("prerelease")]
+print(json.dumps(pre[0]) if pre else "", end="")
+')"
+    else
+        die "dev channel needs jq or python3 to parse GitHub API"
+    fi
+    [[ -n "$result" && "$result" != "null" ]] || die "no prerelease (dev) found"
+    printf '%s' "$result"
+}
+
+release_json_for_spec() {
+    if [[ "$SPEC_FLOATING" -eq 1 ]]; then
+        case "$SPEC_CHANNEL" in
+            stable) latest_stable_json ;;
+            dev)    latest_dev_json ;;
+            night)  die "night has no GitHub release binary" ;;
+        esac
+    else
+        fetch_json "https://api.github.com/repos/dexoron/dcr/releases/tags/v${SPEC_VERSION}"
+    fi
+}
+
+install_prebuilt() {
+    local triple asset tag version id dest mirror
+    need_cmd curl
+    triple="$(detect_triple)"
+    json="$(release_json_for_spec)"
+    tag="$(json_tag "$json")"
+    [[ -n "$tag" ]] || die "failed to parse release tag"
+    version="$(normalize_version "$tag")"
+    asset="dcr-${triple}-${version}"
+    case "$triple" in
+        *windows*) asset="${asset}.exe" ;;
+    esac
+
+    id="$(toolchain_id "$version")"
+    dest="$DCRUP_TC/$id"
+    if [[ -x "$dest/dcr" && "${FORCE:-0}" != "1" ]]; then
+        ok "already installed: $id"
+        link_default "$id"
+        return 0
+    fi
+
+    mkdir -p "$dest"
+    log "downloading $asset (mirror=$DCRUP_MIRROR) …"
+    download_from_mirrors "$tag" "$asset" "$dest" \
+        || die "no mirror reachable for $asset (try: --mirror cf|gh|sf|ya)"
+    mirror="$USED_MIRROR"
+    log "mirror → $mirror"
+    chmod +x "$dest/dcr"
+    printf '%s\n' \
+        "channel=$SPEC_CHANNEL" \
+        "version=$version" \
+        "tag=$tag" \
+        "source=release" \
+        "triple=$triple" \
+        "mirror=$mirror" \
+        "libc=${DCRUP_LIBC:-gnu}" \
+        >"$dest/dcrup-meta"
+    ok "installed prebuilt $id ($triple via $mirror)"
+    link_default "$id"
+}
+
+install_build() {
+    local tmp id dest sha version branch_or_tag
+    need_cmd git
+    need_cmd cargo
+
+    tmp="$(mktemp -d "${TMPDIR:-/tmp}/dcrup.XXXXXX")"
+    cleanup_tmp() { rm -rf "$tmp"; }
+    trap cleanup_tmp EXIT
+
+    if [[ "$SPEC_CHANNEL" == "night" ]]; then
+        log "cloning $REPO_URL (branch dev) for night …"
+        git clone --depth 1 --branch dev "$REPO_URL" "$tmp/src" 2>/dev/null \
+            || git clone --depth 1 "$REPO_URL" "$tmp/src"
+        sha="$(git -C "$tmp/src" rev-parse --short HEAD)"
+        version="night"
+        id="$(toolchain_id "$sha")"
+    elif [[ "$SPEC_FLOATING" -eq 1 ]]; then
+        local json tag
+        json="$(release_json_for_spec)"
+        tag="$(json_tag "$json")"
+        [[ -n "$tag" ]] || die "failed to resolve floating channel tag"
+        version="$(normalize_version "$tag")"
+        id="$(toolchain_id "$version")"
+        log "cloning $REPO_URL @ $tag …"
+        git clone --depth 1 --branch "$tag" "$REPO_URL" "$tmp/src" 2>/dev/null \
+            || {
+                git clone --depth 1 "$REPO_URL" "$tmp/src"
+                git -C "$tmp/src" fetch --depth 1 origin "refs/tags/${tag}:refs/tags/${tag}"
+                git -C "$tmp/src" checkout "$tag"
+            }
+        sha="$(git -C "$tmp/src" rev-parse --short HEAD)"
+    else
+        version="$SPEC_VERSION"
+        id="$(toolchain_id)"
+        local tag="v${SPEC_VERSION}"
+        log "cloning $REPO_URL @ $tag …"
+        git clone --depth 1 --branch "$tag" "$REPO_URL" "$tmp/src" 2>/dev/null \
+            || {
+                git clone --depth 1 "$REPO_URL" "$tmp/src"
+                git -C "$tmp/src" fetch --depth 1 origin "refs/tags/${tag}:refs/tags/${tag}"
+                git -C "$tmp/src" checkout "$tag"
+            }
+        sha="$(git -C "$tmp/src" rev-parse --short HEAD)"
+    fi
+
+    dest="$DCRUP_TC/$id"
+    if [[ -x "$dest/dcr" && "${FORCE:-0}" != "1" ]]; then
+        ok "already installed: $id"
+        link_default "$id"
+        return 0
+    fi
+
+    log "building release (features: $FEATURES) …"
+    (
+        cd "$tmp/src"
+        # shellcheck disable=SC2086
+        cargo build --release --features $FEATURES
+    )
+    mkdir -p "$dest"
+    cp "$tmp/src/target/release/dcr" "$dest/dcr"
+    chmod +x "$dest/dcr"
+    printf '%s\n' "channel=$SPEC_CHANNEL" "version=$version" "git=$sha" "source=build" "features=$FEATURES" >"$dest/dcrup-meta"
+    ok "installed build $id"
+    link_default "$id"
+    trap - EXIT
+    cleanup_tmp
+}
+
+cmd_install() {
+    local mode="release" FORCE=0
+    local spec=""
+    local libc_cli=""
+    while [[ $# -gt 0 ]]; do
+        case "$1" in
+            --build) mode="build"; shift ;;
+            --release) mode="release"; shift ;;
+            --force) FORCE=1; shift ;;
+            --libc)
+                [[ $# -ge 2 ]] || die "--libc needs gnu|musl|auto"
+                libc_cli="$2"
+                shift 2
+                ;;
+            --libc=*)
+                libc_cli="${1#--libc=}"
+                shift
+                ;;
+            --mirror)
+                [[ $# -ge 2 ]] || die "--mirror needs auto|cf|gh|sf|ya"
+                set_mirror "$2"
+                shift 2
+                ;;
+            --mirror=*)
+                set_mirror "${1#--mirror=}"
+                shift
+                ;;
+            -h|--help) usage; exit 0 ;;
+            -*) die "unknown flag: $1" ;;
+            *)
+                [[ -z "$spec" ]] || die "unexpected argument: $1"
+                spec="$1"
+                shift
+                ;;
+        esac
+    done
+    [[ -n "$spec" ]] || die "usage: dcrup install <spec> [--build|--release] [--force] [--libc gnu|musl|auto] [--mirror auto|cf|gh|sf|ya]"
+    parse_spec "$spec"
+    ensure_dirs
+
+    if [[ -n "$libc_cli" ]]; then
+        case "$libc_cli" in
+            gnu|glibc|musl|auto) DCRUP_LIBC="$libc_cli" ;;
+            *) die "invalid --libc: $libc_cli (use gnu|musl|auto)" ;;
+        esac
+    fi
+    export DCRUP_LIBC="${DCRUP_LIBC:-gnu}"
+
+    if [[ "$SPEC_CHANNEL" == "night" ]]; then
+        mode="build"
+    fi
+
+    export FORCE
+    log "install spec=$SPEC_RAW channel=$SPEC_CHANNEL version=${SPEC_VERSION:-∅} mode=$mode libc=$DCRUP_LIBC mirror=$DCRUP_MIRROR"
+    if [[ "$mode" == "build" ]]; then
+        install_build
+    else
+        install_prebuilt
+    fi
+    check_path
+}
+
+cmd_default() {
+    [[ $# -eq 1 ]] || die "usage: dcrup default <spec>"
+    parse_spec "$1"
+    ensure_dirs
+    local id
+    if [[ "$SPEC_CHANNEL" == "night" || "$SPEC_FLOATING" -eq 1 ]]; then
+        id="$(ls -1 "$DCRUP_TC" 2>/dev/null | grep -E "^${SPEC_CHANNEL}-" | sort | tail -n1 || true)"
+        [[ -n "$id" ]] || die "no installed toolchain for channel $SPEC_CHANNEL (run: dcrup install $SPEC_CHANNEL)"
+    else
+        id="$(toolchain_id)"
+        [[ -d "$DCRUP_TC/$id" ]] || die "not installed: $id (run: dcrup install $1)"
+    fi
+    link_default "$id"
+}
+
+cmd_update() {
+    ensure_dirs
+    local active
+    active="$(read_active)"
+    [[ -n "$active" ]] || die "no active toolchain (run: dcrup install stable)"
+    case "$active" in
+        night-*)
+            log "updating night (rebuild HEAD) …"
+            FORCE=1 cmd_install night --build --force
+            ;;
+        stable-*|dev-*)
+            local ch="${active%%-*}"
+            log "updating floating channel $ch …"
+            FORCE=1 cmd_install "$ch" --force
+            ;;
+        *-stable|*-dev)
+            ok "pinned toolchain $active — not floating; install a newer version explicitly"
+            ;;
+        *)
+            warn "unknown active id $active; try: dcrup install stable"
+            ;;
+    esac
+}
+
+cmd_list() {
+    ensure_dirs
+    local active
+    active="$(read_active)"
+    if [[ ! -d "$DCRUP_TC" ]] || [[ -z "$(ls -A "$DCRUP_TC" 2>/dev/null || true)" ]]; then
+        warn "no toolchains installed"
+        return 0
+    fi
+    local d base
+    for d in "$DCRUP_TC"/*; do
+        [[ -d "$d" ]] || continue
+        base="$(basename "$d")"
+        if [[ "$base" == "$active" ]]; then
+            printf ' * %s\n' "$base"
+        else
+            printf '   %s\n' "$base"
+        fi
+    done
+}
+
+cmd_show() {
+    ensure_dirs
+    local active
+    active="$(read_active)"
+    echo "DCRUP_HOME=$DCRUP_HOME"
+    echo "DCRUP_BIN=$DCRUP_BIN"
+    echo "active=${active:-none}"
+    if [[ -n "$active" && -f "$DCRUP_TC/$active/dcrup-meta" ]]; then
+        echo "--- meta ---"
+        cat "$DCRUP_TC/$active/dcrup-meta"
+    fi
+    if [[ -x "$DCRUP_BIN/dcr" ]]; then
+        echo "--- dcr --version ---"
+        "$DCRUP_BIN/dcr" --version 2>/dev/null || true
+    fi
+}
+
+cmd_which() {
+    if [[ -L "$DCRUP_BIN/dcr" || -e "$DCRUP_BIN/dcr" ]]; then
+        readlink -f "$DCRUP_BIN/dcr" 2>/dev/null || readlink "$DCRUP_BIN/dcr" 2>/dev/null || echo "$DCRUP_BIN/dcr"
+    else
+        die "dcr not linked (run: dcrup install stable)"
+    fi
+}
+
+cmd_uninstall() {
+    ensure_dirs
+    if [[ "${1:-}" == "--all" ]]; then
+        rm -rf "$DCRUP_TC"
+        rm -f "$DCRUP_BIN/dcr" "$(active_file)"
+        ok "removed all toolchains"
+        return 0
+    fi
+    [[ $# -eq 1 ]] || die "usage: dcrup uninstall <spec>|--all"
+    parse_spec "$1"
+    local id
+    if [[ "$SPEC_FLOATING" -eq 1 || "$SPEC_CHANNEL" == "night" ]]; then
+        id="$(ls -1 "$DCRUP_TC" 2>/dev/null | grep -E "^${SPEC_CHANNEL}-" | sort | tail -n1 || true)"
+    else
+        id="$(toolchain_id)"
+    fi
+    [[ -n "$id" && -d "$DCRUP_TC/$id" ]] || die "not installed: $1"
+    rm -rf "$DCRUP_TC/$id"
+    if [[ "$(read_active)" == "$id" ]]; then
+        rm -f "$DCRUP_BIN/dcr" "$(active_file)"
+        warn "removed active toolchain; run: dcrup install stable"
+    fi
+    ok "removed $id"
+}
+
+check_path() {
+    case ":$PATH:" in
+        *":$DCRUP_BIN:"*) ;;
+        *)
+            warn "$DCRUP_BIN is not in PATH"
+            echo "Add to ~/.bashrc / ~/.zshrc / ~/.profile:"
+            echo "  export PATH=\"$DCRUP_BIN:\$PATH\""
+            ;;
+    esac
+}
+
+cmd_self_install() {
+    local dest="$DCRUP_BIN"
+    while [[ $# -gt 0 ]]; do
+        case "$1" in
+            --to) dest="$2"; shift 2 ;;
+            *) die "usage: dcrup self-install [--to DIR]" ;;
+        esac
+    done
+    ensure_dirs
+    mkdir -p "$dest"
+    local self
+    self="$(readlink -f "$0" 2>/dev/null || realpath "$0" 2>/dev/null || echo "$0")"
+    cp "$self" "$dest/dcrup"
+    chmod +x "$dest/dcrup"
+    ok "dcrup installed to $dest/dcrup"
+    check_path
+    echo "Then: dcrup install stable"
+}
+
+main() {
+    local cmd="${1:-}"
+    shift || true
+    case "$cmd" in
+        ""|-h|--help|help) usage ;;
+        install) cmd_install "$@" ;;
+        default) cmd_default "$@" ;;
+        update) cmd_update "$@" ;;
+        list) cmd_list "$@" ;;
+        show) cmd_show "$@" ;;
+        which) cmd_which "$@" ;;
+        uninstall) cmd_uninstall "$@" ;;
+        self-install) cmd_self_install "$@" ;;
+        *) die "unknown command: $cmd (try: dcrup help)" ;;
+    esac
+}
+
+main "$@"

docs/README.mdx

@@ -8,8 +8,11 @@ sidebar_label: Introduction
 <summary>Quick reference</summary>
 
 ```bash
-# Installation
+# Installation (dcrup)
-curl -fsSL https://dcr.dexoron.su/install.sh | sh
+curl -fsSL https://sh.dcr-tool.ru | sh -s -- self-install
+export PATH="$HOME/.dcr/bin:$PATH"
+dcrup install stable                 # auto: cf → gh → sf → ya
+# dcrup install stable --mirror cf   # CloudFlare / GitHub / SourceForge / Yandex
 
 # Create a project
 dcr new my-app
@@ -44,17 +47,21 @@ dcr gen vscode
 | [Self Update](/docs/self-update) | Auto-update |
 | [FAQ](/docs/faq) | Frequently asked questions |
 | [Changelog](/docs/changelog) | Version history |
+| [License](/docs/license) | DCR and vendored library licenses |
 | [Contributing](/docs/contributing) | DCR development |
 
 ## Features
 
 - **Incremental builds** — mtime + `.d` headers + SHA256 fingerprint
 - **Parallel compilation** — thread::scope, atomic task queue
-- **4 backends** — gcc/clang, MSVC/clang-cl, GAS (ARM), NASM (x86)
+- **7 backends** — gcc/clang (unix_cc), MSVC/clang-cl (msvc), GAS, NASM, MASM, FASM, LLVM IR
-- **7 project kinds** — bin, staticlib, sharedlib, efi, elf, none, custom
+- **8 project kinds** — bin, staticlib, sharedlib, efi, elf, none, custom, flat-bin
+- **Disk images** — optional `[archive]` packs FAT12/16/32 images after build
 - **Cross-compilation** — short names and full triples
 - **Profiles** — debug / release with field overrides
 - **Workspaces** — multi-package projects with topological sort
 - **Registry + Git + Path** — three dependency mechanisms
 - **IDE generation** — VS Code, CLion, compile_commands.json, JSON metadata
 - **pkg-config** — automatic system library discovery
+- **Per-command `--help`** — `dcr build --help`, `dcr new --help`, etc.
+- **Man pages** — `man dcr`, `man dcr-build`, `man dcr-new`

docs/changelog.mdx

@@ -4,6 +4,239 @@ sidebar_label: Changelog
 
 # Changelog
 
+## 0.9.0 (2026-08-31) 
+
+- **Download mirrors in `dcrup`** — `--mirror auto|cf|gh|sf|ya` and `DCRUP_MIRROR`.
+  Default `auto` tries **cf → gh → sf → ya** (CloudFlare CDN, GitHub, SourceForge, Yandex CDN).
+- **Complete Path/Git dependencies** — DCR packages from `path` and `git` are built before their consumer. Git sources are cached in `~/.dcr/git`, support `branch`/`tag`/`rev`, and record the exact commit in `dcr.lock`.
+- **Build and prebuild modes** — `path` and `git` dependencies can build a DCR package from `dcr.toml` or link existing `include`/`lib`/`libs` artifacts; `mode = "build"` / `"prebuild"` selects explicitly when both forms are present.
+- **Prebuilt dependency examples** — documentation now shows the `dcr-math-lib` Git repository and recommended build/prebuilt layouts for both `git` and `path`.
+- **Transitive dependency builds and cycle reporting** — DCR recursively builds DCR packages and reports a clear dependency chain for cycles.
+- **Bare path arguments for `dcr add`** — `dcr add mylib ../mylib` now works in addition to the explicit `path:` form.
+- **Removed `install.sh` / `install.ps1` / `install_bsd.sh`** — superseded by `dcrup`.
+
+## 0.8.5 (2026-08-08)
+
+- **`package.dcr-version`** — optional CLI version pin in `dcr.toml`.
+  `dcr new` / `dcr init` write the current version. On config load:
+  - missing / empty pin → warn "add dcr-version";
+  - dcr older than pin → warn "update dcr";
+  - dcr newer than pin → warn "check changelog, update pin";
+  - equal → silent.
+    Commands do not fail, warning only (once per path per process).
+
+## 0.8.4 (2026-08-04)
+
+**Added:**
+
+- **`.dcr/` directory** — shared machine-readable build facts for IDE integrations:
+  - `.dcr/compile_commands.json`
+  - `.dcr/build-info.json` (`schemaVersion`, `artifact_path`, `profile`, …)
+  - `.dcr/toolchain.json` (compiler/debugger paths, moc/uic/rcc)
+  - `.dcr/ide/` (placeholder for IDE lock files)
+- **`dcr gen project-info`** — `target`, `target_dir`, `artifact_path`, `artifact_kind`, `source_roots`, `include_globs`, `exclude_globs`; absolute/canonical paths.
+- **`dcr build --print-artifact-path`** — one absolute artifact path line on stdout after a successful build.
+- **`dcr gen … --quiet` / `-q`** — suppress human success logs for gen subcommands.
+- **`.clangd`** — created on first gen with `CompilationDatabase: .dcr` (`# managed by dcr gen`); custom `.clangd` is not overwritten.
+- **Helpers** `canonicalize_path`, `atomic_write`, `ensure_dcr_dir`; pure `resolve_artifact_path` via `platform::*`.
+- **`dcr new` / `dcr init`** — add `.dcr/` to `.gitignore`.
+
+**Changed (breaking):**
+
+- **`compile_commands.json` moved** from project root to **`.dcr/compile_commands.json`**.  
+  clangd discovers it via `.clangd` / `--compile-commands-dir=.dcr`.  
+  CLion and VSCode generators updated accordingly.
+- **Atomic write** for compile_commands (tmp + rename).
+- **`gen vscode` / `gen clion` launch/run** — use the same artifact path resolver as `project-info` / `build-info.json`.
+
+**Fixed:**
+
+- Launch configs no longer hardcode `target/<profile>/<name>` without the Linux triple segment.
+- Symlink/mount roots: best-effort canonicalize for root and compile database paths.
+
+## 0.8.3 (2026-08-03)
+
+### Added
+
+- **`dcr run -- <args>...`** — cargo-style argument forwarding after a bare `--`  
+  (`dcr run --release -- --test_help`). Applies to direct binary runs and `[run].cmd`.
+- **Tests** — host target section `ldflags` without CLI `--target`; run-arg forwarding; `split_double_dash` unit tests.
+
+### Changed
+
+- **Native builds resolve the host triple** — without `--target` / package `build.target`, host sections such as  
+  `[build.x86_64-unknown-linux-gnu]` apply again (`cflags` / `ldflags` / toolchain).  
+  Previously the target was empty and those sections were ignored while artifacts already used the host triple path.
+- **Empty target** — no more `Unknown target ''` warning.
+- **`dcr run --help` / man `dcr-run`** — document `--` forwarding.
+
+### Fixed
+
+- **Native artifact paths on Windows and macOS** — without an explicit `--target` / `build.target`, artifacts use `target/<profile>`, so `dcr run` and flat-bin find the build output.
+- Target-specific `ldflags` missing on native host builds (e.g. micro-lang + `libsct-elf`).
+- Spurious empty-target warning.
+
+## 0.8.2 (2026-07-22)
+
+### Added
+
+- **Compile progress `[N/M]`** — live TTY status line (`compile  pkg v0.1.0  [12/41]`) so long mono-package builds do not look hung.
+- **DCR status style** — fixed-width verbs: `project`, `compile`, `dep`, `ready`, `pack`, `done`, `run`.
+- **Cargo feature `archive`** — optional FAT packing via `fatfs` (`cargo build --features archive`). Release CI builds with the feature; without it `[archive]` fails with a clear message.
+- **Tests** — `flat_bin_nasm_build`, package `build.target` without CLI `--target`, stricter workspace `clean --all`.
+- **CI expansion** — unit + integration on Linux/macOS/Windows, archive feature job, rust-cache, clippy default + all-features (see `.github/workflows/ci.yml`).
+
+### Changed
+
+- **No forced host triple from CLI** — without `--target`, package/member `build.target` is honored (bare-metal / ISO `post_steps` paths).
+- **Relative include/lib flags** (`-I`, `-i`, `-isystem`, `-idirafter`, `-L`, `-T`) absolutized against the package root under workspace builds.
+- **`dcr clean --all`** — no spam for members without a local `target/` (shared root `target/`).
+- **`error` / `warn`** — red / yellow on stderr; CLI fully English (`Hint:`).
+- **Help / man** — list `add`, `lint`, `setup`; unknown command exits with code 1.
+- **Tool NotFound** — `linker not found: ld.lld …` / `{tool} not found …` instead of raw `os error 2`.
+
+## 0.8.1 (2026-07-20)
+
+### Added
+
+- **`build.kind = "flat-bin"`** — raw binary (default `.bin`) for OS-dev payloads:
+  - **NASM** — `-f bin` → `<stem>.bin`
+  - **FASM** — direct output (`format binary` in source)
+  - **GAS / MASM / LLC** — object → `objcopy -O binary` → `<stem>.bin`
+  - **C/C++** — objects → freestanding link → `objcopy -O binary` → `<name>.bin`
+  - Requires `llvm-objcopy` / `objcopy` / `gobjcopy` except for NASM/FASM direct emit
+- **`[archive]` section** — FAT12/16/32 disk images after build (`output`, `format`, `size`, `offset`, `label`, `bootsector`, `layout`). From 0.8.2 requires feature `archive`.
+- **Single-file `build.roots`** — a root may be a single source or header file, not only a directory.
+
+### Changed
+
+- **`--force`** also re-runs `build.steps` and `build.post_steps`.
+- **`dcr run` on workspace-only root** — if `[run].cmd` is set, run that after build; otherwise delegate to a workspace member.
+
+## 0.8.0 (2026-07-18)
+
+### Added
+
+- **Dedicated Build Engine (`src/core/build/engine.rs`)** — decoupled the build orchestration logic completely from the CLI front-end wrapper in `src/cli/build.rs` to a reusable, decoupled core build engine.
+- **Polymorphic Language Model (`Language` trait)** — introduced the abstract `Language` trait (`src/core/build/language/mod.rs`). File scanning, compiler resolution, and flags handling are now encapsulated in dedicated language modules for C, C++ (including Qt code generation), LLVM IR, and ASM (GAS, NASM, FASM, MASM).
+- **Polymorphic Compilation Dispatch (`Builder` trait)** — introduced the `Builder` trait to generalize builder invocations (`src/core/build/builder/mod.rs`). Consolidated GCC/Clang logic into `builder/cc_common.rs` and Microsoft Visual C++ logic into `builder/msvc/`.
+- **Per-Language Configuration overrides (`[build.<lang>]`)** — introduced support for configuring language-specific compiler, standard, and flags (e.g. `[build.c]`, `[build.cxx]`, `[build.asm]`) independently in `dcr.toml`.
+- **Automatic Workspace Dependency Injection** — during workspace builds, include/lib paths of dependent workspace members (including their source headers, local `include/` folders, and build target `target/include` / `target/lib` folders) are automatically resolved and injected.
+- **`BuildReporter` Event System** — decoupled build orchestration output into a structured event-driven reporter model (`src/core/build/report.rs`), making DCR suitable for library embedding and IDE integrations without stderr capturing.
+- **Build Cancellation Support** — introduced thread-safe cancellation tokens (`Arc<AtomicBool>`) allowing clients to safely abort compile runs mid-execution.
+- **TOML Formatting & Custom Keys Preservation** — migrated the config editor to `toml_edit`, preserving all unknown/user-defined TOML keys, structures, and comments during file write operations (e.g., in `dcr add`).
+- **Path Dependencies Target Include Resolution** — local path dependencies configured via tables now correctly expose headers built and packaged into their `target/include` folder to consumer packages.
+- **Modular Integration Test Suite** — refactored the monolith `tests/cli_basic.rs` file into clean, specialized integration tests: `cli_build.rs`, `cli_deps.rs`, `cli_lint.rs`, `cli_new.rs`, `cli_qt.rs`, `cli_test.rs`, `cli_workspace.rs`.
+
+### Changed
+
+- **Consolidated Linking and Archiving** — artifact generation (linking executables/shared libraries and archiving static libraries) consolidated into a single `src/core/build/builder/artifact.rs` module.
+- **Workspace-Aware member execution** — `dcr run` executed at the workspace root of a `workspace_only` project now triggers the member build inside the workspace context using the `--workspace` parameter, preventing standalone build issues.
+- **Elimination of Global State** — removed global variables and states from the build core, encapsulating build logic inside isolated `BuildContext` structs for thread safety.
+- **Build Cache Separation** — relocated mtime tracking, incremental caching, and header-dependency checking logic to `src/core/build/cache.rs`.
+- **Modularized Pre-build Steps** — decoupled generator scripts and pre-build commands parsing into `src/core/build/steps.rs`.
+
+## 0.7.4 (2026-06-17)
+
+### Added
+
+- **Native Qt support** — automatic meta-object handling (MOC, UIC, RCC) added when `build.qt = true` is set in `dcr.toml`.
+- **`dcr lint` command** — C/C++ static analysis via `clang-tidy`. Supports `--fix` for automatic fixes. Respects `build.roots` and `build.src_disable` from config.
+- **Three new assembler backends**:
+  - **MASM** (`compiler = "ml"` / `"ml64"`) — Microsoft Macro Assembler.
+  - **FASM** (`compiler = "fasm"`) — Flat Assembler.
+  - **LLVM IR** (`compiler = "llc"`) — compiles `.ll` files via `llc -filetype=obj`.
+- **Shared ASM pipeline** — linking and archiving logic consolidated into `core/builder/asm.rs`. Adding a new assembler backend now takes ~30 lines.
+- **Filesystem utilities** — `to_hex()` and `home_dir()` extracted to `utils/fs.rs`.
+- **Build utilities** — `normalize_target()`, `normalize_kind()`, `normalize_platform()`, `default_profile_flags()` extracted to `utils/build.rs`.
+- **Backend helpers** — `asm_lang_flag()`, `source_extensions()`, `elapsed_secs()` added to `core/builder/common.rs`.
+- **Full Bare-Metal / Freestanding Automation** — introduced the `build.freestanding = true` configuration option. When enabled (or when a bare-metal target is detected), DCR automatically injects `-ffreestanding` during compilation and both `-nostdlib` and `-static` during linking.
+- **Artifact Optimization (LTO & Strip)** — added `build.lto` (auto-injects `-flto` for compiler and linker) and `build.strip` (automatically strips debug symbols via linker `-s` flag) options to `dcr.toml`.
+- **Compilation Thread Control** — added the `build.codegen-units` option to strictly limit the maximum number of parallel jobs utilized by the custom `parallel_build` worker pool.
+- **Panic Behavior Management** — added `build.panic = "abort"` support. For C++ targets, it automatically strips exception handling and unwind tables via `-fno-exceptions`, `-fno-unwind-tables`, and `-fno-asynchronous-unwind-tables`.
+
+### Changed
+
+- **Intelligent Default Flags Generation** — automated injection of fallback optimization (`-O3`/`-O0`), debug (`-g`), and warning (`-Wall -Wextra`) flags is now suppressed for bare-metal and freestanding builds if `build.cflags` are overridden.
+- **Centralized Bare-Metal Detection** — relocated the `is_bare_metal_target` helper to common build utilities (`src/utils/build.rs`) for unified access across the building core.
+- **Architectural Refactoring**:
+  - Renamed `src/config.rs` to `src/templates.rs`.
+  - Started consolidation of configuration and build orchestration logic.
+
+## 0.7.3 (2026-06-13)
+
+### Added
+
+- **`--vcs` option for `new` and `init` commands** — introduced explicit version control system selection via `--vcs <git|none>`.
+- **Git metadata integration in `--version`** — the CLI now appends the current short commit hash and a `-dirty` suffix if there are uncommitted changes in the DCR repository.
+- **Automatic `.gitignore` generation** — Git repository initialization now automatically writes a `.gitignore` file excluding the `/target` directory.
+- **Nested repository prevention** — automatic Git initialization is now skipped if `dcr new` or `dcr init` is executed inside an already existing Git repository.
+- **VCS verification tests** — added `new_vcs_options_work` and `init_vcs_options_work` integration tests to ensure reliable repository behavior.
+
+### Changed
+
+- **Complete removal of `git2` dependency** — all Git actions (dependency fetching, VCS setup, status checks) are now delegated to the system `git` executable via `Command`. This simplifies compilation and drops the need for `vendored` and `openssl` features.
+- **Migrated from `reqwest` to `ureq`** — replaced the heavy `reqwest` crate in `flag_update.rs` with the lightweight synchronous `ureq 2.10` client, reducing overhead and the final binary size.
+
+## 0.7.2 (2026-06-07)
+
+### Added
+
+- `default_target_triple()` now respects `target_env` — Linux (gnu/musl) and Windows (msvc/gnu) use the correct environment instead of hardcoded values.
+
+### Fixed
+
+- **macOS Apple Silicon builds failed with `_main` undefined** — `--target=` is now passed to ldflags, not just cflags. `default_target_triple()` uses `std::env::consts::ARCH` on macOS instead of hardcoded `x86_64`.
+- **GitHub Stars and GPL-3.0 badges not rendering in README** — badge block converted to pure HTML.
+
+### Changed
+
+- Default target resolution extracted into shared `default_target_triple()` — removed duplication across build, run, clean.
+
+## 0.7.1 (2026-06-02)
+
+### Added
+
+- **`--help` for all commands** — `dcr build --help`, `dcr run --help`, `dcr new --help`,
+  `dcr init --help`, `dcr clean --help`, `dcr add --help`, `dcr fmt --help`,
+  `dcr setup --help`, `dcr tree --help`, `dcr gen --help`, `dcr --update --help`,
+  `dcr test --help`. All output uses styled headers (green) and usage lines (cyan).
+- **Man pages** — 12 troff pages in `man/man1/`: `dcr.1`, `dcr-build.1`,
+  `dcr-run.1`, `dcr-new.1`, `dcr-init.1`, `dcr-clean.1`, `dcr-add.1`, `dcr-test.1`,
+  `dcr-gen.1`, `dcr-fmt.1`, `dcr-tree.1`, `dcr-setup.1`.
+- **Man pages in all packaging** — install.sh, install_bsd.sh, AUR PKGBUILD,
+  Debian (cargo-deb), RPM (cargo-generate-rpm), Nix (postInstall), Homebrew
+  (resource), Snap, GitHub Release assets.
+- **Project name validation** — `dcr init` and `dcr new` now validate names before
+  creating files. Only ASCII letters, digits, `_` and `-` are allowed.
+- **`documentation` and `homepage` fields** — added to `Cargo.toml`.
+- **Release profile optimizations** — `opt-level = "z"`, LTO, `codegen-units = 1`,
+  `panic = "abort"`, `strip = true` for smaller binaries.
+- **Linux i686, armv7, riscv64 targets** — added to release workflow and install scripts.
+- **Linux musl i686, armv7 targets** — cross-compiled via zigbuild in CI.
+- **AUR packages** — `dcr-dev`, `dcr-dev-bin` publishing workflow.
+- **Snap publishing** — automated Snapcraft publishing in CI.
+- **Snap badge** — in README.
+
+### Changed
+
+- **`validate_package_name` made public** — callable from CLI commands.
+- **README platform table** — reorganized: libc variants as separate OS rows,
+  removed extra columns. Linux architecture list updated.
+- **`gen.rs` no-args output** — now uses styled output instead of raw `eprintln!`.
+- **`tree.rs`, `fmt.rs`, and `setup.rs`** — now accept arguments for `--help`.
+- **README install commands** — `| bash` → `| sh` for POSIX compatibility.
+
+### Fixed
+
+- **`dcr new <invalid-name>` creates directory then fails** — validation now
+  happens before any file operations.
+- **`dcr init` on invalid directory name** — same fix.
+- **Man pages missing in installed packages** — now shipped in all formats.
+- **Windows drive letter false positive** — in dependency file parser.
+- **CRLF (`\r\n`) breaks dependency parser** — now handles mixed line endings.
+- **Newline after backslash not consumed** — in `parse_d_file` escape handling.
+
 ## 0.7.0 (2026-06-01)
 
 ### Added

docs/commands/build-commands.mdx

@@ -13,7 +13,7 @@ dcr build                         # debug profile
 dcr build --release               # release build
 dcr build --debug                 # explicit debug
 dcr build --target aarch64-unknown-linux-gnu
-dcr build --force                 # full rebuild
+dcr build --force                 # full rebuild (also re-runs build.steps / post_steps)
 dcr build --clean                 # clean + build
 dcr build --verbose               # show compilation commands
 dcr build --workspace pkg-a       # build specific workspace package
@@ -21,6 +21,8 @@ dcr build --workspace pkg-a       # build specific workspace package
 
 Artifacts: `target/<triple>/<profile>/<binary-name>` (Linux with explicit target).
 
+With `[archive]` in `dcr.toml`, a FAT disk image is packed after a successful build.
+
 ## `dcr run`
 
 Builds (if sources are newer than artifacts) and runs the binary.
@@ -28,8 +30,11 @@ Builds (if sources are newer than artifacts) and runs the binary.
 ```bash
 dcr run
 dcr run --release
+dcr run --force                   # force rebuild then run
 ```
 
+On a **workspace-only** root: if `[run].cmd` is set, that command is used after build; otherwise DCR delegates to a workspace member.
+
 ## `dcr clean`
 
 Removes `target/` directory (or `target/<target>/<profile>`).

docs/commands/dependency-commands.mdx

@@ -29,7 +29,7 @@ Flags:
 - `--tag <name>` — git tag
 - `--rev <hash>` — git commit
 
-If source is omitted — DCR searches connected registries.
+If source is omitted — DCR searches connected registries. A bare relative or absolute path is accepted as a path dependency.
 
 ## `dcr tree`
 

docs/commands/project-commands.mdx

@@ -8,10 +8,16 @@ sidebar_label: Project commands (new, init)
 
 Creates a new project with a standard structure and `dcr.toml`. The `name` argument is required.
 
+Only ASCII letters, digits, underscores `_` and hyphens `-` are allowed in the project name.
+
 ```bash
 dcr new my-app
+dcr new my-app --vcs none
 ```
 
+Flags:
+- `--vcs <git|none>` — Initialize version control system (defaults to `git` if available, or `none`).
+
 Generates:
 - `dcr.toml` with basic fields
 - `src/main.c` with a `main` template
@@ -21,8 +27,11 @@ Generates:
 Initializes a DCR project in the current (empty) directory.
 
 ```bash
-mkdir app && cd app
 dcr init
+dcr init --vcs none
 ```
 
-The project name is taken from the current directory name.
+Flags:
+- `--vcs <git|none>` — Initialize version control system (defaults to `git` if available, or `none`).
+
+The project name is taken from the current directory name. The directory name must follow the same naming rules as `dcr new`.

docs/commands/quality-commands.mdx

@@ -42,3 +42,18 @@ dcr fmt
 Processes: `src/**/*.{c,cpp,cxx,cc,h,hpp,hxx,hh}` and `tests/**/*.{c,cpp,cxx,cc,h,hpp,hxx,hh}`.
 
 Uses `.clang-format` at the project root (if present), otherwise default clang-format style.
+
+## `dcr lint`
+
+Runs `clang-tidy` on C/C++ source files for static analysis.
+
+```bash
+dcr lint              # show diagnostics
+dcr lint --fix        # apply fixes automatically
+dcr lint --help       # detailed help
+```
+
+Processes: `src/**/*.{c,cpp,cxx,cc}` and `tests/**/*.{c,cpp,cxx,cc}`.
+
+Without `--fix`, clang-tidy reports warnings and errors without modifying files.
+With `--fix`, clang-tidy applies automatic suggestions in place.

docs/commands/system-commands.mdx

@@ -15,9 +15,9 @@ dcr setup
 If `~/.dcr/config.toml` is not found, DCR returns an error. Create it manually:
 
 ```toml
-[[registry]]
+[registry.default]
-name = "default"
 url = "https://index.dcr.pm"
+priority = 1
 ```
 
 ## `dcr --help`

docs/contributing.mdx

@@ -8,6 +8,7 @@ sidebar_label: Contributing
 
 ```bash
 git clone https://github.com/dexoron/dcr
+# or a source mirror: GitVerse / SourceCraft / SourceForge / GitLab (see README)
 cd dcr
 cargo build
 ```
@@ -42,9 +43,10 @@ cargo test --all-targets
 
 ## CI
 
-CI runs:
+CI runs (see `.github/workflows/ci.yml`):
 - `cargo fmt --check`
-- `cargo clippy --all-targets -- -D warnings`
+- `cargo clippy` (default + `--all-features`)
-- `cargo test --all-targets`
+- `cargo check --all-targets --all-features`
-- Build on Linux, macOS, Windows
+- Unit + integration tests on Linux, macOS, Windows
-- Integration tests
+- Extra Linux job with `--features archive` (FAT images)
+- Tools on runners: clang, nasm, clang-format/tidy (Linux)

docs/faq.mdx

@@ -13,9 +13,9 @@ error: registry not found
 **Solution:** Make sure `~/.dcr/config.toml` exists:
 
 ```toml
-[[registry]]
+[registry.default]
-name = "default"
 url = "https://index.dcr.pm"
+priority = 1
 ```
 
 And check `DCR_INDEX_PATH`:
@@ -39,27 +39,6 @@ which clang
 
 Or specify explicitly via `[toolchain]` in `dcr.toml`.
 
-## openssl-sys build failed
-
-When building DCR from source:
-
-```
-error: failed to run custom build command for openssl-sys
-```
-
-**Solution:** Install OpenSSL development headers:
-
-```bash
-# Ubuntu/Debian
-sudo apt install libssl-dev
-
-# Fedora
-sudo dnf install openssl-devel
-
-# macOS
-brew install openssl
-```
-
 ## Ctrl+C during build
 
 DCR handles SIGINT: interrupts the current compilation and exits with non-zero code.
@@ -76,6 +55,21 @@ See [Cross-Compile Recipe](/docs/recipes/cross-to-windows).
 
 See [Workspace Recipe](/docs/recipes/multi-package-workspace).
 
+## Bootloader / pure NASM OS image
+
+Use `kind = "flat-bin"` (NASM `-f bin`) and optional `[archive]` for a FAT disk image.
+
+See [OS-dev recipe](/docs/recipes/os-flat-bin-archive).
+
+## How do I choose a download mirror?
+
+`dcrup install` uses `--mirror auto` by default and tries **cf → gh → sf → ya**.
+
+```bash
+dcrup install stable --mirror cf
+export DCRUP_MIRROR=ya
+```
+
 ## Lock file
 
 `dcr.lock` is created during builds (`dcr build`) when registry dependencies are present. To force an update — delete `dcr.lock` and run `dcr build`.

docs/getting-started/first-steps.mdx

@@ -68,3 +68,11 @@ dcr test             # run tests
 ```bash
 dcr fmt              # clang-format with .clang-format
 ```
+
+## Linting
+
+```bash
+dcr lint             # clang-tidy checks
+dcr lint --fix       # apply fixes automatically
+```
+

docs/getting-started/installation.mdx

@@ -4,25 +4,82 @@ sidebar_label: Installation
 
 # Installation
 
-## Linux (Dexoron Packages)
+## dcrup (recommended)
 
-Configure your package manager at https://dcr.dexoron.su and install:
+Install and switch DCR versions (stable / dev / night, pin `0.8.2`, optional build from source).
+
+### Linux / macOS / BSD / Windows (bash)
 
-**Arch Linux**
 ```sh
-sudo pacman -Sy dcr
+curl -fsSL https://sh.dcr-tool.ru | sh -s -- self-install
+export PATH="$HOME/.dcr/bin:$PATH"
+dcrup install stable
 ```
 
-**Debian/Ubuntu**
+Non-interactive install of DCR in one shot:
+
 ```sh
-sudo apt update && sudo apt install dcr
+curl -fsSL https://sh.dcr-tool.ru | sh -s -- install stable
+export PATH="$HOME/.dcr/bin:$PATH"
 ```
 
-**Fedora/RHEL**
+### Windows (PowerShell)
-```sh
+
-sudo dnf install dcr
+```powershell
+irm https://ps1.dcr-tool.ru | iex
+# or download then run:
+# irm https://ps1.dcr-tool.ru -OutFile dcrup.ps1
+# powershell -File .\dcrup.ps1 self-install
+# $env:Path += ";$env:USERPROFILE\.dcr\bin"
+dcrup install stable
 ```
 
+Optional cmd bootstrap (if you prefer `curl` of the cmd shim):
+
+```bat
+curl -fsSL -o dcrup.cmd https://cmd.dcr-tool.ru
+```
+
+After `self-install`, the command is **`dcrup`** (no `.sh` / `.ps1`): shims live in `~/.dcr/bin` (Unix) or `%USERPROFILE%\.dcr\bin` (Windows `dcrup.cmd`).
+
+### Common dcrup commands
+
+```sh
+dcrup install stable              # latest stable prebuilt (auto: cf → gh → sf → ya)
+dcrup install 0.8.2               # pin → 0.8.2@stable
+dcrup install 0.8.2@dev
+dcrup install stable --libc musl  # Linux: musl asset (default: gnu)
+dcrup install stable --mirror cf  # CloudFlare CDN
+dcrup install stable --mirror ya  # Yandex CDN (RU fallback)
+dcrup install stable --build      # cargo build --features archive
+dcrup install night               # always build from branch dev HEAD
+dcrup default 0.8.2
+dcrup update
+dcrup list
+dcrup show
+dcrup which
+```
+
+Layout: `~/.dcr/toolchains/<id>/dcr` and `~/.dcr/bin/dcr` → active version.
+
+### Download mirrors
+
+Prebuilt installs try **cf → gh → sf → ya** unless you pin a host.
+
+| Code | URL | Notes |
+|------|-----|--------|
+| `cf` | `https://cdn-global.dcr-tool.ru/<tag>/<asset>` | CloudFlare CDN (worldwide) |
+| `gh` | `https://github.com/dexoron/dcr/releases/download/<tag>/<asset>` | GitHub Releases |
+| `sf` | `https://sourceforge.net/projects/dcr-tool/files/<tag>/<asset>/download` | SourceForge |
+| `ya` | `https://cdn-ru.dcr-tool.ru/<tag>/<asset>` | Yandex CDN (RU fallback) |
+
+```sh
+dcrup install stable --mirror auto   # default
+export DCRUP_MIRROR=cf               # persist for this shell
+```
+
+---
+
 ## Arch Linux (AUR)
 
 ```sh
@@ -36,11 +93,18 @@ brew tap dexoron/dexoron
 brew install dcr
 ```
 
+## Snap (Linux)
+
+```sh
+sudo snap install dcrup
+```
+
+> If classic Snap Store publishing is unavailable, install the `.snap` from [GitHub Releases](https://github.com/dexoron/dcr/releases/latest) with `--dangerous`.
+
 ## Nix (flake)
 
 ```sh
 nix run github:dexoron/dcr
-# or install to profile:
 nix profile install github:dexoron/dcr
 ```
 
@@ -50,44 +114,40 @@ nix profile install github:dexoron/dcr
 cargo install dcr
 ```
 
-## Linux / macOS (script)
+Note: crates.io builds may omit optional features. For FAT disk images (`[archive]`), prefer release binaries or:
 
 ```sh
-curl -fsSL https://dcr.dexoron.su/install.sh | bash
+cargo install dcr --features archive
-```
-
-## BSD (script)
-
-```sh
-curl -fsSL https://dcr.dexoron.su/install_bsd.sh | bash
-```
-
-## Windows (PowerShell)
-
-```powershell
-irm https://dcr.dexoron.su/install.ps1 | iex
 ```
 
 ## From source
 
 ```sh
 git clone https://github.com/dexoron/dcr.git
-cd dcr && cargo build --release
+cd dcr
+cargo build --release --features archive
 ln -sf "$PWD/target/release/dcr" ~/.local/bin/dcr
+# or manage versions with dcrup install night / --build
 ```
 
 ## Post-install
 
-Verify the installation:
-
 ```bash
 dcr --version
+dcrup show    # if installed via dcrup
 ```
 
-To use the registry, create `~/.dcr/config.toml`:
+Man pages (package installs / release assets):
+
+```bash
+man dcr
+man dcr-build
+```
+
+Registry (optional) — `~/.dcr/config.toml`:
 
 ```toml
-[[registry]]
+[registry.default]
-name = "default"
 url = "https://index.dcr.pm"
+priority = 1
 ```

docs/ide-integration.mdx

@@ -6,6 +6,13 @@ sidebar_label: IDE Integration
 
 ## VS Code
 
+Install the recommended [DCR extension by Dexoron-Labs](https://marketplace.visualstudio.com/items?itemName=Dexoron-Labs.dcr). Do not install Microsoft C/C++ extensions for DCR projects: DCR uses `clangd`. MS C/C++ is acceptable only when you need its debugger.
+
+Recommended companion extensions:
+
+- [Even Better TOML](https://marketplace.visualstudio.com/items?itemName=tamasfe.even-better-toml)
+- [CodeLLDB](https://marketplace.visualstudio.com/items?itemName=vadimcn.vscode-lldb), or MS C/C++ for debugger support only
+
 ```bash
 dcr gen vscode
 ```

docs/license.mdx

@@ -0,0 +1,33 @@
+---
+sidebar_label: License
+---
+
+# License
+
+## DCR
+
+DCR itself is [GPL-3.0-or-later](https://spdx.org/licenses/GPL-3.0-or-later.html) licensed.
+
+> **Note:** DCR is a build tool, not a library. The GPL applies only to DCR's own source code. Projects built with DCR are not subject to DCR's license — their licensing is determined solely by their own code and dependencies.
+
+## Rust dependencies
+
+DCR is written in Rust. The following notable Rust crates are statically linked:
+
+| Crate | License |
+|---|---|
+| [`ureq`](https://crates.io/crates/ureq) | MIT OR Apache-2.0 |
+| [`serde`](https://crates.io/crates/serde) | MIT OR Apache-2.0 |
+| [`toml`](https://crates.io/crates/toml) | MIT OR Apache-2.0 |
+| [`toml_edit`](https://crates.io/crates/toml_edit) | MIT OR Apache-2.0 |
+| [`serde_json`](https://crates.io/crates/serde_json) | MIT OR Apache-2.0 |
+| [`sha2`](https://crates.io/crates/sha2) | MIT OR Apache-2.0 |
+| [`glob`](https://crates.io/crates/glob) | MIT OR Apache-2.0 |
+| [`self-replace`](https://crates.io/crates/self-replace) | MIT OR Apache-2.0 |
+| [`ctrlc`](https://crates.io/crates/ctrlc) | MIT OR Apache-2.0 |
+
+Full dependency tree is available in [`Cargo.lock`](https://github.com/dexoron/dcr/blob/main/Cargo.lock). The overwhelming majority are dual-licensed under MIT OR Apache-2.0.
+
+## Additional credits
+
+- DCR's CLI design and project model are inspired by [Cargo](https://doc.rust-lang.org/cargo/).

docs/recipes/multi-package-workspace.mdx

@@ -34,6 +34,7 @@ type = "none"
 inherit = true
 language = "c"
 standard = "c11"
+workspace_only = true
 
 [workspace.lib-core]
 path = "lib-core"

docs/recipes/os-flat-bin-archive.mdx

@@ -0,0 +1,89 @@
+---
+sidebar_label: OS-dev (flat-bin + archive)
+---
+
+# Pure ASM / boot image (flat-bin + archive)
+
+Minimal OS-dev style pipeline: assemble raw binaries with NASM, then pack a FAT floppy/image with an optional boot sector.
+
+## Project layout
+
+```
+myos/
+  dcr.toml
+  src/
+    boot.asm      # boot sector (512 bytes)
+    kernel.asm    # payload
+```
+
+For multiple flat artifacts, use a **workspace** (one member per binary) or separate packages; a single `flat-bin` package produces one binary per source stem.
+
+## Boot package (`flat-bin`)
+
+```toml
+[package]
+name = "boot"
+version = "0.1.0"
+
+[build]
+language = "asm"
+compiler = "nasm"
+kind = "flat-bin"
+extension = "bin"
+roots = ["src/boot.asm"]
+```
+
+```bash
+dcr build
+# → target/<…>/debug/boot.bin  (NASM -f bin, no link)
+```
+
+## Disk image after build
+
+```toml
+[archive]
+output = "target/{profile}/disk.img"
+format = "fat12"
+size = "1440K"
+label = "MYOS"
+bootsector = "target/{profile}/boot.bin"
+
+[[archive.layout]]
+from = "target/{profile}/kernel.bin"
+to = "KERNEL.BIN"
+```
+
+- `format`: `fat12`, `fat16`, or `fat32`
+- `size`: bytes or `K`/`KB`/`M`/`MB`/`G`/`GB` (default ~1.44 MiB)
+- `bootsector`: written only when `offset` is omitted or `0`
+- `from` may be a glob; `{profile}` is substituted in paths
+
+## C kernel → flat binary
+
+```toml
+[build]
+language = "c"
+compiler = "clang"
+kind = "flat-bin"
+freestanding = true
+filename = "kernel"
+extension = "bin"
+ldflags = ["-T", "linker.ld"]
+```
+
+Pipeline: objects → temporary linked ELF → `objcopy -O binary` → `kernel.bin`. Requires `objcopy` / `llvm-objcopy` in PATH.
+
+## Other assemblers
+
+| Tool | Notes |
+|------|--------|
+| **FASM** | Write `format binary` in the source; DCR writes `<stem>.bin` directly |
+| **GAS** | Assemble `.s` → obj → `objcopy -O binary` |
+| **LLC** | `language = "llvm_ir"` → obj → objcopy |
+| **MASM** | COFF obj → objcopy (needs binutils/LLVM objcopy) |
+
+## Notes
+
+- Single-file `roots` are supported: `roots = ["src/boot.asm"]`.
+- `--force` re-runs `build.steps` / `build.post_steps` as well as recompilation.
+- Prefer `kind = "elf"` if you need a relocatable ELF kernel without stripping to raw binary.

docs/reference/build-profiles.mdx

@@ -32,11 +32,37 @@ Set `inherit = false` to disable array inheritance (only profile's own arrays ar
 
 ## Built-in profiles
 
-| Profile | Default cflags |
+The default flags for each profile are composed from three config fields:
+
+| Field | debug default | release default |
+|-------|--------------|----------------|
+| `opt_level` | `"0"` | `"3"` |
+| `debug` | `true` | `false` |
+| `warnings` | `["all", "extra"]` | `[]` |
+
+Which produce the equivalent compiler flags:
+
+| Profile | Effective flags |
 |---------|---------------|
 | `debug` | `-O0 -g -Wall -Wextra -fno-omit-frame-pointer -DDCR_DEBUG` |
 | `release` | `-O3 -DNDEBUG` |
 
+Additional build options can be toggled per-profile:
+
+```toml
+[build.release]
+opt_level = "z"
+lto = true
+strip = true
+panic = "abort"
+codegen-units = "1"
+
+[build.debug]
+opt_level = "1"
+debug = false
+warnings = ["all", "error"]
+```
+
 ## Target-specific profiles
 
 ```toml

docs/reference/build-system.mdx

@@ -6,30 +6,60 @@ sidebar_label: Build system
 
 ## Compiler Backends
 
-DCR supports 4 compilation backends. Selection is automatic based on file extension.
+DCR supports 7 compilation backends. Selection is automatic based on file extension and `build.compiler` value.
 
 | Backend | Files | When used |
 |---------|-------|-----------|
 | `unix_cc` | `.c`, `.cpp`, `.cxx`, `.cc`, `.S` | gcc/clang on Linux/macOS/BSD |
 | `msvc` | `.c`, `.cpp`, `.cxx`, `.cc` | Windows (cl, clang-cl) |
 | `gas` | `.s` | ARM/ARM64 assembler (no preprocessor) |
-| `nasm` | `.asm` | x86/x86_64 assembler |
+| `nasm` | `.asm`, `.s` | x86/x86_64 NASM assembler |
+| `masm` | `.asm` | MASM (ml/ml64) on Windows |
+| `fasm` | `.asm`, `.fasm` | Flat Assembler |
+| `llvm_ir` | `.ll` | LLVM IR via `llc -filetype=obj` |
+
+## Qt Support
+
+DCR provides native Qt support for automatic meta-object handling (MOC, UIC, RCC).
+
+Enable it by setting `build.qt = true` in `dcr.toml`. DCR will automatically detect Qt-related files (`.ui`, `.qrc`, `.h` with `Q_OBJECT`) and process them.
+
+```toml
+[build]
+qt = true
+```
+
+*Note: Requires `qt6` modules (Core, Widgets, Gui, Svg) installed via `pkg-config`.*
+
+Advanced customization is still possible via `build.steps` if special handling is needed:
+
+```toml
+[build.steps]
+moc = "moc {in} -o {out}"
+```
 
 ### Unix CC
 
 - Compiler resolved via `resolve_compiler()`: `DCR_COMPILER` > `DCR_CC` > `[toolchain]` > `build.compiler` > `PATH`
 - Supports `.d` files for header dependency tracking
 - Flags: `-std=`, `-MMD -MF`, `-c -o`, `-I`, `-L`, `-l`
+- Conditional flags based on config:
+  - `freestanding` or bare-metal target: `-ffreestanding` (compile), `-nostdlib -static` (link)
+  - `lto`: `-flto` (compile + link)
+  - `panic = "abort"`: `-fno-exceptions` (C++ only), `-fno-unwind-tables`, `-fno-asynchronous-unwind-tables`
 
 ### MSVC
 
 - Supports cl.exe and clang-cl.exe
 - Flags: `/std:`, `/Fo:`, `/Fe:`, `/I`, `/link`
 
-### GAS / NASM
+### GAS / NASM / MASM / FASM / LLVM-IR
 
 - GAS: `-I`, `-c -o`, `--defsym`
-- NASM: `-I`, `-o`, `-D`, `-f` (format: win64/elf64/macho64/macho32/elf32)
+- NASM: `-I`, `-o`, `-D`, `-f` (format: win64/elf64/macho64/macho32/elf32; **`bin` when `kind = "flat-bin"`**)
+- MASM: `/nologo /c /Fo<obj> <source>`
+- FASM: `<source> <output>` (output path is the object file)
+- LLVM IR: `-filetype=obj <source> -o <output>`
 
 ## Incremental Builds
 
@@ -44,7 +74,7 @@ Three levels of incrementality:
 - `thread::scope` for thread pool
 - Atomic task queue (`AtomicU64`)
 - Mutex on stdout (`OUTPUT_MUTEX`)
-- Thread count = `available_parallelism()`
+- Thread count = `available_parallelism()`, capped by `build.codegen-units` if set
 
 ## Build Kinds
 
@@ -57,6 +87,11 @@ Three levels of incrementality:
 | `elf` | ELF without stdlib | `target/<triple>/<profile>/<name>` |
 | `none` | Compile only, no link | — |
 | `custom` | Full filename+extension control | `target/<triple>/<profile>/<filename>.<extension>` |
+| `flat-bin` | Raw binary | ASM: `<stem>.bin` (NASM `-f bin` / FASM / GAS·MASM·LLC via objcopy); C/C++: `<name>.bin` (link + objcopy) |
+
+## Disk images (`[archive]`)
+
+After a successful build, if `[archive]` is present in `dcr.toml`, DCR formats a FAT volume and copies files from `layout` into the image. See [dcr.toml → archive](/docs/reference/dcr-toml#archive).
 
 ## Build Steps
 

docs/reference/cross-compilation.mdx

@@ -37,9 +37,19 @@ target = "aarch64-unknown-linux-gnu"
 # Auto: cflags += ["--target=aarch64-unknown-linux-gnu"]
 ```
 
-## Bare-Metal
+## Bare-Metal / Freestanding
 
-For targets containing `none`, `-elf`, `eabi`, or `baremetal`, DCR default flags are disabled (no system include paths, no `-l` libc).
+For targets containing `none`, `-elf`, `eabi`, or `baremetal`, DCR automatically:
+
+1. **Disables default flags** — no system include paths, no `-l` libc
+2. **Injects `-ffreestanding`** at compile time and `-nostdlib -static` at link time
+
+You can also enable freestanding mode explicitly:
+
+```toml
+[build]
+freestanding = true
+```
 
 ```bash
 dcr build --target aarch64-none-elf
@@ -47,14 +57,8 @@ dcr build --target aarch64-none-elf
 
 ## Target Directory
 
-On Linux with explicit target:
+By default, the compilation output directories are structured as follows:
 
-```
+- **Linux and BSD**: Always output to `target/<triple>/<profile>/` (using host triple if no target is specified).
-target/<triple>/<profile>/
+- **macOS and Windows (without target)**: Output to `target/<profile>/`.
-```
+- **macOS and Windows (with explicit target)**: Output to `target/<triple>/<profile>/`.
-
-On macOS/Windows or without target:
-
-```
-target/<profile>/
-```

docs/reference/dcr-toml.mdx

@@ -33,6 +33,9 @@ Main project configuration file. Located at the project root.
 
 [run]
 # run settings
+
+[archive]
+# optional: pack FAT disk image after build
 ```
 
 ## [package]
@@ -40,8 +43,9 @@ Main project configuration file. Located at the project root.
 | Field | Required | Description |
 |-------|----------|-------------|
 | `name` | yes | Project name |
-| `version` | yes | Semantic version |
+| `version` | yes | Semantic version of the **project** |
-| `type` | yes | `app`, `lib`, `none` |
+| `dcr-version` | no | Semver of the **dcr tool** this project targets. Written by `dcr new` / `dcr init` to the current tool version. |
+| `type` | no | `app`, `lib`, `none` (defaults to `"none"`) |
 | `license` | no | SPDX license identifier |
 | `author` | no | Author |
 
@@ -49,40 +53,95 @@ Main project configuration file. Located at the project root.
 [package]
 name = "my-app"
 version = "0.1.0"
+dcr-version = "0.8.4"
 type = "app"
 license = "MIT"
 author = "John Doe"
 ```
 
+### `package.dcr-version`
+
+Optional pin of the DCR CLI the project was written for. On every `dcr.toml` load:
+
+| Situation | Behaviour |
+|-----------|-----------|
+| Field missing / empty | Warning: add `dcr-version` (set by `dcr new` / `dcr init`) |
+| Running dcr **older** than pin | Warning: upgrade dcr (`dcr --update`) |
+| Running dcr **newer** than pin | Warning: review changelog, bump the pin when ready |
+| Equal | Silent |
+| Invalid semver | Warning once, field ignored |
+
+Never fails the command — warnings only. Pre-release suffixes (`1.0.0-dev`) are ignored for comparison (`1.0.0-dev` ≡ `1.0.0`).
+
 ## [build]
 
+...
+
+- `build.qt` — (bool) Enable automatic Qt meta-object handling (MOC, UIC, RCC). Requires `qt6` modules installed via `pkg-config`.
+
 | Field | Default | Description |
 |-------|---------|-------------|
-| `language` | `"c"` | `"c"`, `"c++"`, `"cpp"`, `"cxx"`, `"asm"` |
+| `language` | `"c"` | `"c"`, `"c++"`, `"cpp"`, `"cxx"`, `"asm"`, `"llvm_ir"`, `"llvm-ir"`, `"ll"` (optional, defaults to `"c"`) |
 | `standard` | `"c11"` | C standard (`c11`, `c17`, `c23`) |
-| `cxx_standard` | `"c++20"` | C++ standard (`c++17`, `c++20`, `c++23`) |
+| `cxx_standard` | — | C++ standard (`c++17`, `c++20`, `c++23`) |
-| `compiler` | `"clang"` | Preferred compiler |
+| `compiler` | `"clang"` | Preferred compiler (optional, defaults to `"clang"`) |
-| `kind` | `"bin"` | `bin`, `staticlib`, `sharedlib`, `efi`, `elf`, `none`, `custom` |
+| `kind` | `"bin"` | `bin`, `staticlib`, `sharedlib`, `efi`, `elf`, `none`, `custom`, `flat-bin` |
 | `target` | host | Target triple for cross-compilation |
-| `platform` | `"native"` | `native`, `efi`, `freestanding` |
+| `platform` | `"native"` | `native`, `efi` |
 | `cflags` | `[]` | Additional C/C++/ASM flags |
 | `ldflags` | `[]` | Additional linker flags |
 | `filename` | `""` | Custom output file name |
-| `extension` | `""` | Custom file extension |
+| `extension` | `""` | Custom file extension (for `flat-bin`, default is `bin`) |
-| `roots` | `["src"]` | Source root directories |
+| `roots` | `["src"]` | Source roots: directories and/or individual source/header files |
 | `exclude` | `[]` | Exclude patterns |
 | `include` | `[]` | Additional include directories |
 | `src_disable` | `false` | Disable auto source discovery |
 | `inherit` | `false` | Inherit build from workspace root |
 | `clean` | `[]` | Glob patterns for custom clean paths |
 | `out_dir` | `""` | Custom output directory |
-| `workspace_only` | `false` | Workspace-only, not built standalone |
+| `workspace_only` | `false` | Workspace-only, not built standalone (no `language`/`compiler` required) |
+| `freestanding` | `false` | Compile in freestanding mode (`-ffreestanding` + `-nostdlib -static`) |
+| `opt_level` | — | Optimization level: `0`-`3`, `"s"`, `"z"` (derived from profile if omitted) |
+| `debug` | profile-based | Emit debug symbols (`-g`): `true` in debug, `false` in release |
+| `lto` | `false` | Link-time optimization (`-flto` for both compiler and linker) |
+| `strip` | `false` | Strip symbols from output (`-s` in ldflags) |
+| `warnings` | `[]` | Warning flags (e.g. `"all"`, `"extra"`, `"pedantic"`); engine adds `-Wall -Wextra` in debug if empty |
+| `panic` | `""` | Panic strategy: `"abort"` disables exceptions and unwind tables |
+| `codegen-units` | `""` | Max parallel compilation jobs (`"0"` = auto) |
+| `qt` | `false` | Enable automatic Qt meta-object handling (MOC, UIC, RCC) |
 
 Settings from raw config (not in typed struct):
 - `pkg_config` — list of pkg-config packages
 - `ldscript` — linker script path
 - `build.steps` / `build.post_steps` — codegen steps
 
+## Per-language overrides: `[build.c]`, `[build.cxx]`, `[build.asm]`, `[build.llvm_ir]`
+
+Each language can have its own table that overrides the flat `[build]` settings:
+
+```toml
+[build]
+compiler = "clang"
+standard = "c11"
+
+[build.c]
+standard = "c23"
+compiler = "gcc"
+
+[build.cxx]
+standard = "c++23"
+compiler = "g++"
+
+[build.asm]
+compiler = "nasm"
+flags = ["-felf64"]
+
+[build.llvm_ir]
+compiler = "llc"
+```
+
+The flat `[build]` acts as fallback; per-language tables take precedence for their language.
+
 Example:
 
 ```toml
@@ -93,6 +152,11 @@ cxx_standard = "c++23"
 compiler = "clang"
 kind = "sharedlib"
 cflags = ["-Wall", "-Wextra"]
+opt_level = "z"
+lto = true
+strip = true
+panic = "abort"
+codegen-units = "2"
 ```
 
 ## [toolchain]
@@ -130,3 +194,84 @@ Default `cmd` = `./target/{profile}/{name}` (macOS/Windows) or `./target/<triple
 ## [workspace]
 
 See [workspaces](/docs/reference/workspaces).
+
+## [archive]
+
+Optional post-build step: format a FAT volume and copy built artifacts into a disk image. Runs after a successful package build (and after workspace member builds that define `[archive]`).
+
+Requires DCR built with the `archive` Cargo feature (`cargo build --features archive`). Release binaries include this feature.
+
+| Field | Required | Description |
+|-------|----------|-------------|
+| `output` | yes | Image path relative to project root (`{profile}` allowed) |
+| `format` | yes | `fat12`, `fat16`, or `fat32` |
+| `size` | no | Image size: bytes or `K`/`KB`/`M`/`MB`/`G`/`GB` (default `1474560` ≈ 1.44 MiB) |
+| `offset` | no | Byte offset of the FAT volume inside the image (default `0`) |
+| `label` | no | Volume label (max 11 chars, default `VOLUME`) |
+| `bootsector` | no | Path to a 512-byte boot sector written at offset 0 when `offset` is 0 (`{profile}` allowed) |
+| `layout` | no | List of `{ from, to }` entries (files or globs → path inside the volume) |
+
+```toml
+[archive]
+output = "target/{profile}/disk.img"
+format = "fat12"
+size = "1440K"
+label = "MYOS"
+bootsector = "target/{profile}/boot.bin"
+
+[[archive.layout]]
+from = "target/{profile}/kernel.bin"
+to = "KERNEL.BIN"
+
+[[archive.layout]]
+from = "assets/*"
+to = "/"
+```
+
+Typical pairing with `kind = "flat-bin"` (NASM `-f bin`) for bootloaders and pure-ASM OS images.
+
+## `flat-bin` (kind)
+
+Produces a raw binary (default extension `bin`) for boot sectors, kernels, and freestanding payloads.
+
+### Assemblers
+
+| Tool | Language / compiler | How flat-bin is produced |
+|------|---------------------|--------------------------|
+| NASM | `language = "asm"`, `compiler = "nasm"` | `-f bin` → `<stem>.bin` |
+| FASM | `compiler = "fasm"` | direct write (use `format binary` in source) |
+| GAS | `compiler = "as"` / `"gas"` | assemble → `objcopy -O binary` |
+| MASM | `compiler = "ml"` / `"ml64"` | assemble → `objcopy -O binary` |
+| LLC | `language = "llvm_ir"`, `compiler = "llc"` | `-filetype=obj` → `objcopy -O binary` |
+
+```toml
+[build]
+language = "asm"
+compiler = "nasm"
+kind = "flat-bin"
+extension = "bin"
+roots = ["src/boot.asm"]
+```
+
+### C / C++
+
+Compile all sources, link with `-nostdlib -static` (plus your `ldflags` / `ldscript`), then convert the intermediate ELF/PE with `objcopy -O binary` to `<filename|name>.bin`.
+
+```toml
+[build]
+language = "c"
+compiler = "clang"
+kind = "flat-bin"
+freestanding = true
+filename = "kernel"
+extension = "bin"
+ldscript = "linker.ld"
+ldflags = ["-T", "linker.ld"]
+```
+
+Notes:
+
+- Multi-file **ASM** packages emit one `<stem>.bin` per source; **C/C++** emit a single project binary.
+- `objcopy` tools tried in order: `llvm-objcopy`, `objcopy`, `gobjcopy`.
+- Incompatible with `build.qt = true`.
+- `dcr run` rejects `flat-bin` (not a host executable).

docs/reference/dependencies.mdx

@@ -23,10 +23,10 @@ The version string is used as-is for registry lookup.
 
 ```toml
 [dependencies]
-fmt = { git = "https://github.com/fmtlib/fmt", tag = "10.1.1" }
+dcr-math = { git = "https://github.com/dexoron/dcr-math-lib.git", tag = "v0.1.0" }
 ```
 
-Fields: `git`, `branch`, `tag`, `rev`.
+Fields: `git`, `branch`, `tag`, `rev`, `mode`, `include`, `lib`, `libs`.
 
 ### Table (path)
 
@@ -35,33 +35,56 @@ Fields: `git`, `branch`, `tag`, `rev`.
 mylib = { path = "../mylib" }
 ```
 
+For a prebuilt external library, specify its layout explicitly. The three
+arrays are paths relative to the dependency root (`include`, `lib`) and linker
+names (`libs`):
+
+```toml
+[dependencies]
+dcr-math = { path = "../deps/dcr-math", include = ["include"], lib = ["lib"], libs = ["dcr-math"] }
+```
+
 ## Registry
 
 DCR uses a package registry for dependency lookup by name.
 
 ```toml
 # ~/.dcr/config.toml
-[[registry]]
+[registry.default]
-name = "default"
+url = "https://index.dcr.dexoron.tech"
-url = "https://index.dcr.pm"
+priority = 1
 ```
 
 Registry priority: order in `config.toml`. The `DCR_INDEX_PATH` variable overrides the path to `index.json`.
 
 ## Git dependencies
 
-DCR clones git repositories via `git2`:
+Git dependencies are cloned into `~/.dcr/git/`; their exact checked-out commit is written to `dcr.lock`.
+
+Both Git and path dependencies have two modes:
+
+- **DCR package:** the source has `dcr.toml`. DCR builds it before the consumer and uses the package name from its manifest for linking.
+- **Prebuilt library:** it provides existing headers and binaries through `include`, `lib`, and `libs`. DCR passes them to the compiler/linker without building the dependency.
+
+The mode is normally detected automatically. Use `mode = "build"` or `mode = "prebuild"` when a source contains both a manifest and prebuilt artifacts and you need to choose explicitly.
+
+`dcr-math-lib` publishes both forms. Select its prebuilt library explicitly:
+
+```toml
+[dependencies]
+dcr-math = { git = "https://github.com/dexoron/dcr-math-lib.git", tag = "v0.1.0", mode = "prebuild", include = ["include"], lib = ["lib"], libs = ["dcr-math"] }
+```
+
+DCR supports specifying branch/tag/rev for git sources:
 
 - `branch` — switch to a branch
 - `tag` — switch to a tag
 - `rev` — switch to a specific commit
 - `features` — feature flags (parsed, but does not affect build)
 
-Cache path: `~/.dcr/git/<hash>/`.
-
 ## Path dependencies
 
-Local paths. DCR automatically discovers include and lib directories from the neighbor's `dcr.toml`.
+Local paths may point at a DCR package or a prebuilt external library. A path DCR package is built before its consumer, including its own path/git dependencies. DCR detects dependency cycles. A prebuilt library is never built by DCR; it is linked from the directories declared in its dependency entry.
 
 ```toml
 [dependencies]
@@ -69,16 +92,51 @@ mylib = { path = "/abs/path/to/lib" }
 mylib = { path = "../relative/path" }
 ```
 
+For DCR packages, the package name from `dcr.toml` is used for linking (so the dependency key may differ from the library name). Header resolution includes the packaged `target/include` directory and link search includes `target/lib`.
+
+### Recommended library layouts
+
+Buildable DCR library:
+
+```text
+dcr-math-lib/
+├── dcr.toml
+└── src/
+    ├── dcr_math.c
+    └── dcr_math.h
+```
+
+Prebuilt library:
+
+```text
+dcr-math-lib/
+├── include/
+│   └── dcr_math.h
+└── lib/
+    └── libdcr-math.a       # or .so / .lib
+```
+
+`libs` contains linker names without the `lib` prefix and file extension: use
+`["dcr-math"]` for `libdcr-math.a`.
+
+If one repository contains both forms, keep the prebuilt files in `include/` and `lib/` and select the mode explicitly:
+
+```toml
+[dependencies]
+dcr-math = { git = "https://github.com/dexoron/dcr-math-lib.git", tag = "v0.1.0", mode = "prebuild", include = ["include"], lib = ["lib"], libs = ["dcr-math"] }
+```
+
+For a local copy, replace `git` with `path = "../dcr-math-lib"`. In `prebuild` mode DCR does not run the dependency build, even when `dcr.toml` is present.
+
 ## dcr.lock
 
 Dependency lock file. Contains package names and sources.
 
-Created during `dcr build` when registry dependencies are present. Not updated during `dcr add` — only on the next `dcr build`.
+Created during `dcr build` for resolved registry, path, and Git dependencies. Not updated during `dcr add` — only on the next `dcr build`.
 
 ## Resolution process
 
-1. Load all dependencies (registry → git → path)
+1. Resolve dependency sources (registry → git → path)
-2. For path deps: recursively read their `dcr.toml`
+2. Fetch git dependencies into `~/.dcr/git/` and check out the requested ref
-3. For registry deps: search `index.json`
+3. Build DCR package dependencies recursively
-4. For git deps: clone to cache
+4. Collect `include_dirs`, `lib_dirs`, `libs` for the compiler
-5. Collect `include_dirs`, `lib_dirs`, `libs` for the compiler

docs/reference/environment-variables.mdx

@@ -57,3 +57,27 @@ export DCR_INDEX_PATH=/custom/path/index.json
 ```
 
 Default: `~/.dcr/index.json`.
+
+## DCRUP_MIRROR
+
+Download mirror for `dcrup` (prebuilt binaries only).
+
+```bash
+export DCRUP_MIRROR=auto   # cf → gh → sf → ya (default)
+export DCRUP_MIRROR=cf     # CloudFlare CDN
+export DCRUP_MIRROR=gh     # GitHub Releases
+export DCRUP_MIRROR=sf     # SourceForge
+export DCRUP_MIRROR=ya     # Yandex CDN (RU fallback)
+```
+
+CLI override: `dcrup install stable --mirror cf`.
+
+## DCRUP_HOME / DCRUP_BIN / DCRUP_REPO
+
+Installer layout and source clone URL:
+
+```bash
+export DCRUP_HOME=~/.dcr
+export DCRUP_BIN=~/.dcr/bin
+export DCRUP_REPO=https://github.com/dexoron/dcr
+```

docs/reference/platform-support.mdx

@@ -11,17 +11,18 @@ DCR normalizes target triples. Short platform names are expanded to full triples
 ### Linux
 
 ```
-target/<arch>-unknown-linux-gnu/<profile>/
+target/<arch>-unknown-linux-<env>/<profile>/
 ```
 
-Architectures: `x86_64`, `aarch64` (host-detected).
+Architectures: `x86_64`, `aarch64`, `i686`, `armv7`, `riscv64` (host-detected).
+Environments: `gnu` (default), `musl`.
 
 Artifact type: ELF. Extensions: `.so` (sharedlib), `.a` (staticlib).
 
 ### macOS
 
 ```
-target/<profile>/
+target/<profile>/ (default) or target/<triple>/<profile>/ (with target)
 ```
 
 Architectures: `x86_64`, `aarch64` (host-detected).
@@ -31,10 +32,11 @@ Extensions: `.dylib` (sharedlib), `.a` (staticlib).
 ### Windows
 
 ```
-target/<profile>/
+target/<profile>/ (default) or target/<triple>/<profile>/ (with target)
 ```
 
 Architectures: `x86_64`, `aarch64`.
+Environments: `msvc` (default), `gnu` (MinGW).
 
 Extensions: `.exe` (bin), `.lib` (staticlib), `.dll` (sharedlib), `.efi` (UEFI).
 

docs/reference/workspaces.mdx

@@ -43,7 +43,9 @@ dcr build                    # build all packages in dependency order
 dcr build --workspace app    # build only app (dependencies built automatically)
 ```
 
-When building a workspace, member outputs (libraries) are automatically added to include/lib paths of dependent packages.
+When building a workspace, DCR automatically injects include and library paths of dependent workspace members:
+- **Include Paths**: Automatically resolves and injects header directories of dependencies, including the member's `src/` directory, local `include/` directory, and the packaged `target/include` directory.
+- **Library Paths**: Injects compiled library search paths (`target/lib` as well as target-specific build folders) to allow automatic linking with member libraries.
 
 ## Clean
 
@@ -65,3 +67,21 @@ standard = "c17"
 
 # member inherits language and standard
 ```
+
+## Workspace-only root (no build of its own)
+
+A workspace root can set `workspace_only = true` — it won't be built itself, and doesn't need `language` or `compiler`:
+
+```toml
+[package]
+name = "my-workspace"
+version = "0.1.0"
+
+[build]
+workspace_only = true
+kind = "bin"
+
+[workspace]
+lib-core = { path = "lib-core" }
+app = { path = "app", deps = ["lib-core"] }
+```

flake.nix

@@ -64,6 +64,10 @@
           pkgs.darwin.apple_sdk.frameworks.SystemConfiguration
         ];
 
+        postInstall = ''
+          install -Dm644 man/man1/*.1 -t $out/share/man/man1/
+        '';
+
         # Tests require external services; run separately.
         doCheck = false;
       };

install.ps1

@@ -1,154 +0,0 @@
-$ErrorActionPreference = 'Stop'
-
-$RepoUrl    = 'https://github.com/dexoron/dcr'
-$ApiLatest  = 'https://api.github.com/repos/dexoron/dcr/releases/latest'
-$ApiAll     = 'https://api.github.com/repos/dexoron/dcr/releases'
-$InstallPath = Join-Path $env:LOCALAPPDATA 'dcr'
-$BinPath     = Join-Path $env:USERPROFILE '.local\bin'
-$BinaryPath  = Join-Path $InstallPath 'dcr.exe'
-
-function Info($msg)  { Write-Host "[INFO] $msg"  -ForegroundColor Cyan   }
-function Ok($msg)    { Write-Host "[OK] $msg"    -ForegroundColor Green  }
-function Warn($msg)  { Write-Host "[WARN] $msg"  -ForegroundColor Yellow }
-function Fail($msg)  { Write-Host "[ERROR] $msg" -ForegroundColor Red; exit 1 }
-
-function Require-Cmd($name) {
-    if (-not (Get-Command $name -ErrorAction SilentlyContinue)) {
-        Fail "Not found: $name"
-    }
-}
-
-function Select-Channel {
-    Write-Host "Choose channel:"
-    Write-Host "  1) Latest stable release (default)"
-    Write-Host "  2) Latest dev (pre-release)"
-    $choice = Read-Host "Enter 1 or 2 [1]"
-    if ([string]::IsNullOrWhiteSpace($choice)) { $choice = '1' }
-
-    switch ($choice) {
-        '1' { return 'stable' }
-        '2' { return 'dev'    }
-        default { Fail 'Unknown option' }
-    }
-}
-
-function Select-Mode {
-    Write-Host "Choose installation mode:"
-    Write-Host "  1) Download prebuilt binary from GitHub Release (recommended)"
-    Write-Host "  2) Build from git"
-    $choice = Read-Host "Enter 1 or 2 [1]"
-    if ([string]::IsNullOrWhiteSpace($choice)) { $choice = '1' }
-
-    switch ($choice) {
-        '1' { return 'release' }
-        '2' { return 'build'   }
-        default { Fail 'Unknown option' }
-    }
-}
-
-function Get-Target {
-    if ($env:PROCESSOR_ARCHITECTURE -ne 'AMD64') {
-        Fail "Only x86_64 Windows is supported, current architecture: $env:PROCESSOR_ARCHITECTURE"
-    }
-    return 'x86_64-pc-windows-msvc'
-}
-
-function Fetch-ReleaseJson($channel) {
-    if ($channel -eq 'dev') {
-        Info "Looking for latest dev (pre-release)..."
-        $releases = Invoke-RestMethod -Method Get -Uri $ApiAll
-        $pre = $releases | Where-Object { $_.prerelease -eq $true } | Select-Object -First 1
-        if (-not $pre) { Fail "No dev (pre-release) found on GitHub" }
-        return $pre
-    } else {
-        return Invoke-RestMethod -Method Get -Uri $ApiLatest
-    }
-}
-
-function Install-FromRelease {
-    param([string]$target, [string]$channel)
-
-    New-Item -ItemType Directory -Path $InstallPath -Force | Out-Null
-
-    $release = Fetch-ReleaseJson $channel
-    $tag     = $release.tag_name
-    $version = $tag.TrimStart('v')
-
-    # Имя бинарника: dcr-<triple>-<version>.exe
-    $assetName = "dcr-$target-$version.exe"
-
-    Info "Fetching release $tag (channel: $channel)..."
-
-    $asset = $release.assets | Where-Object { $_.name -eq $assetName } | Select-Object -First 1
-    if (-not $asset) {
-        Fail "Asset $assetName not found in release $tag"
-    }
-
-    Info "Downloading $assetName..."
-    Invoke-WebRequest -Uri $asset.browser_download_url -OutFile $BinaryPath
-    Ok "Binary downloaded: $assetName"
-}
-
-function Install-FromSource {
-    param([string]$target, [string]$channel)
-
-    Require-Cmd 'git'
-    Require-Cmd 'cargo'
-
-    $tmp = Join-Path $env:TEMP 'dcr-install'
-    if (Test-Path $tmp) { Remove-Item -Recurse -Force $tmp }
-
-    Info 'Cloning repository...'
-    if ($channel -eq 'dev') {
-        # Пробуем ветку dev
-        $result = git clone --depth 1 --branch dev $RepoUrl $tmp 2>&1
-        if ($LASTEXITCODE -ne 0) {
-            git clone --depth 1 $RepoUrl $tmp | Out-Null
-        }
-    } else {
-        git clone --depth 1 $RepoUrl $tmp | Out-Null
-    }
-
-    Info 'Building release binary...'
-    Push-Location $tmp
-    cargo build --release --target $target
-    Pop-Location
-
-    New-Item -ItemType Directory -Path $InstallPath -Force | Out-Null
-    Copy-Item (Join-Path $tmp "target\$target\release\dcr.exe") $BinaryPath -Force
-    Ok 'Binary installed from source'
-
-    Remove-Item -Recurse -Force $tmp
-}
-
-function Setup-Path {
-    New-Item -ItemType Directory -Path $BinPath -Force | Out-Null
-    $linkPath = Join-Path $BinPath 'dcr.exe'
-    Copy-Item $BinaryPath $linkPath -Force
-
-    $userPath = [Environment]::GetEnvironmentVariable('Path', 'User')
-    if (-not $userPath) { $userPath = '' }
-
-    if (-not ($userPath -split ';' | Where-Object { $_ -eq $BinPath })) {
-        $newPath = if ($userPath) { "$userPath;$BinPath" } else { $BinPath }
-        [Environment]::SetEnvironmentVariable('Path', $newPath, 'User')
-        $env:Path = "$env:Path;$BinPath"
-        Warn "Added path to PATH: $BinPath"
-    }
-
-    Ok "dcr command is available via $linkPath"
-}
-
-Info 'Starting DCR installation'
-$channel = Select-Channel
-$mode    = Select-Mode
-$target  = Get-Target
-
-if ($mode -eq 'build') {
-    Install-FromSource -target $target -channel $channel
-} else {
-    Install-FromRelease -target $target -channel $channel
-}
-
-Setup-Path
-Ok 'Installation completed successfully'

install.sh

@@ -1,232 +0,0 @@
-#!/usr/bin/env bash
-set -Eeuo pipefail
-
-TMPDIR="/tmp/dcr-install"
-INSTALL_PATH="$HOME/.local/share/dcr"
-BINPATH="$HOME/.local/bin"
-LOGFILE="$HOME/.cache/dcr-install.log"
-REPO_URL="https://github.com/dexoron/dcr"
-GITHUB_API_LATEST="https://api.github.com/repos/dexoron/dcr/releases/latest"
-GITHUB_API_ALL="https://api.github.com/repos/dexoron/dcr/releases"
-
-RED='\033[0;31m'
-GREEN='\033[0;32m'
-YELLOW='\033[1;33m'
-BLUE='\033[0;34m'
-NC='\033[0m'
-
-mkdir -p "$(dirname "$LOGFILE")"
-exec > >(tee -a "$LOGFILE") 2>&1
-
-log()     { echo -e "${BLUE}[$(date '+%Y-%m-%d %H:%M:%S')]${NC} $1"; }
-success() { echo -e "${GREEN}✔ $1${NC}"; }
-warn()    { echo -e "${YELLOW}⚠ $1${NC}"; }
-error()   { echo -e "${RED}✖ $1${NC}"; }
-
-trap 'error "Error on line $LINENO"; exit 1' ERR
-
-INSTALL_MODE=""
-CHANNEL=""
-
-check_os() {
-    case "$(uname -s)" in
-        Linux|Darwin|FreeBSD|OpenBSD|NetBSD) ;;
-        *) error "Only Linux, macOS, and BSD systems are supported"; exit 1 ;;
-    esac
-}
-
-detect_target() {
-    local os arch
-    os="$(uname -s)"
-    arch="$(uname -m)"
-
-    case "$os:$arch" in
-        Linux:x86_64)                      TARGET_TRIPLE="x86_64-unknown-linux-gnu" ;;
-        Linux:aarch64|Linux:arm64)         TARGET_TRIPLE="aarch64-unknown-linux-gnu" ;;
-        Darwin:x86_64)                     TARGET_TRIPLE="x86_64-apple-darwin" ;;
-        Darwin:arm64|Darwin:aarch64)       TARGET_TRIPLE="aarch64-apple-darwin" ;;
-        FreeBSD:x86_64|FreeBSD:amd64)      TARGET_TRIPLE="x86_64-unknown-freebsd" ;;
-        OpenBSD:x86_64|OpenBSD:amd64)      TARGET_TRIPLE="x86_64-unknown-openbsd" ;;
-        NetBSD:x86_64|NetBSD:amd64)        TARGET_TRIPLE="x86_64-unknown-netbsd" ;;
-
-        *) error "Unsupported platform: $os/$arch"; exit 1 ;;
-    esac
-}
-
-check_common_dependencies() {
-    command -v curl >/dev/null 2>&1 || { error "curl is not installed"; exit 1; }
-    if [[ "$CHANNEL" == "dev" ]]; then
-        if ! command -v python3 >/dev/null 2>&1 && ! command -v jq >/dev/null 2>&1; then
-            error "For dev installations, either 'python3' or 'jq' must be installed to parse GitHub API response."
-            exit 1
-        fi
-    fi
-}
-
-check_build_dependencies() {
-    command -v git   >/dev/null 2>&1 || { error "git is not installed"; exit 1; }
-    command -v cargo >/dev/null 2>&1 || { error "cargo is not installed"; exit 1; }
-}
-
-select_channel() {
-    echo "Choose channel:"
-    echo "  1) Latest stable release (default)"
-    echo "  2) Latest dev (pre-release)"
-    read -r -p "Enter 1 or 2 [1]: " choice < /dev/tty
-
-    case "${choice:-1}" in
-        1) CHANNEL="stable" ;;
-        2) CHANNEL="dev"    ;;
-        *) error "Unknown option"; exit 1 ;;
-    esac
-}
-
-select_install_mode() {
-    echo "Choose installation mode:"
-    echo "  1) Download prebuilt binary from GitHub Release (recommended)"
-    echo "  2) Build from git"
-    read -r -p "Enter 1 or 2 [1]: " choice < /dev/tty
-
-    case "${choice:-1}" in
-        1) INSTALL_MODE="release" ;;
-        2) INSTALL_MODE="build"   ;;
-        *) error "Unknown option"; exit 1 ;;
-    esac
-}
-
-# Returns JSON of the requested release to stdout
-fetch_release_json() {
-    if [[ "$CHANNEL" == "dev" ]]; then
-        log "Looking for latest dev (pre-release)..."
-        local json result
-        json="$(curl -fsSL "$GITHUB_API_ALL")"
-        if command -v jq >/dev/null 2>&1; then
-            result="$(printf '%s' "$json" | jq -e -c 'map(select(.prerelease == true))[0]')"
-        else
-            result="$(printf '%s' "$json" | python3 - <<'EOF'
-import sys, json
-releases = json.load(sys.stdin)
-pre = [r for r in releases if r.get("prerelease", False)]
-if not pre:
-    print("{}", end="")
-else:
-    print(json.dumps(pre[0]), end="")
-EOF
-)"
-        fi
-
-        if [[ -z "$result" || "$result" == "{}" || "$result" == "null" ]]; then
-            error "No dev (pre-release) found on GitHub"
-            exit 1
-        fi
-        printf '%s' "$result"
-    else
-        curl -fsSL "$GITHUB_API_LATEST"
-    fi
-}
-
-download_binary() {
-    local release_json tag version asset_name download_url
-
-    release_json="$(fetch_release_json)"
-
-    tag="$(printf '%s\n' "$release_json" | \
-        sed -n 's/.*"tag_name": "\([^"]*\)".*/\1/p' | head -n1)"
-    if [[ -z "$tag" ]]; then
-        error "Failed to determine release version"
-        exit 1
-    fi
-
-    # Version without leading 'v'
-    version="${tag#v}"
-    # Binary name: dcr-<triple>-<version>
-    asset_name="dcr-${TARGET_TRIPLE}-${version}"
-
-    log "Fetching release ${tag} (channel: ${CHANNEL})..."
-
-    download_url="$(printf '%s\n' "$release_json" | \
-        sed -n "s#.*\"browser_download_url\": \"\([^\"]*/${asset_name}\)\".*#\1#p" | head -n1)"
-
-    if [[ -z "$download_url" ]]; then
-        error "Asset ${asset_name} not found in release ${tag}"
-        exit 1
-    fi
-
-    mkdir -p "$INSTALL_PATH"
-    curl -fL "$download_url" -o "$INSTALL_PATH/dcr"
-    chmod +x "$INSTALL_PATH/dcr"
-    success "Binary ${asset_name} downloaded (${tag})"
-}
-
-prepare_sources() {
-    log "Fetching sources..."
-    rm -rf "$TMPDIR"
-    git clone --depth 1 "$REPO_URL" "$TMPDIR"
-    if [[ "$CHANNEL" == "dev" ]]; then
-        # Clone dev branch if it exists
-        git clone --depth 1 --branch dev "$REPO_URL" "$TMPDIR" 2>/dev/null || \
-        git clone --depth 1 "$REPO_URL" "$TMPDIR"
-    fi
-    success "Sources fetched"
-}
-
-build_binary() {
-    log "Building release binary..."
-    (cd "$TMPDIR" && cargo build --release)
-    success "Build completed"
-}
-
-install_built_binary() {
-    mkdir -p "$INSTALL_PATH"
-    cp "$TMPDIR/target/release/dcr" "$INSTALL_PATH/dcr"
-    chmod +x "$INSTALL_PATH/dcr"
-    success "Binary installed from source"
-}
-
-install_link() {
-    log "Creating symlink..."
-    mkdir -p "$BINPATH"
-    ln -sf "$INSTALL_PATH/dcr" "$BINPATH/dcr"
-    success "Command 'dcr' added to $BINPATH"
-}
-
-check_path() {
-    if ! echo "$PATH" | grep -q "$BINPATH"; then
-        warn "Directory $BINPATH not found in PATH"
-        echo "Add this to ~/.bashrc or ~/.zshrc:"
-        echo "export PATH=\"$BINPATH:\$PATH\""
-    fi
-}
-
-cleanup() {
-    rm -rf "$TMPDIR" 2>/dev/null || true
-}
-
-main() {
-    log "Starting DCR installation"
-
-    check_os
-    detect_target
-    select_channel
-    check_common_dependencies
-    select_install_mode
-    cleanup
-
-    if [[ "$INSTALL_MODE" == "build" ]]; then
-        check_build_dependencies
-        prepare_sources
-        build_binary
-        install_built_binary
-    else
-        download_binary
-    fi
-
-    install_link
-    check_path
-    cleanup
-
-    success "Installation completed successfully"
-    log "Log saved to $LOGFILE"
-}
-
-main "$@"

install_bsd.sh

@@ -1,223 +0,0 @@
-#!/bin/sh
-set -eu
-
-TMPDIR="/tmp/dcr-install"
-INSTALL_PATH="$HOME/.local/share/dcr"
-BINPATH="$HOME/.local/bin"
-LOGFILE="$HOME/.cache/dcr-install.log"
-REPO_URL="https://github.com/dexoron/dcr"
-GITHUB_API_LATEST="https://api.github.com/repos/dexoron/dcr/releases/latest"
-GITHUB_API_ALL="https://api.github.com/repos/dexoron/dcr/releases"
-
-RED='\033[0;31m'
-GREEN='\033[0;32m'
-YELLOW='\033[1;33m'
-BLUE='\033[0;34m'
-NC='\033[0m'
-
-mkdir -p "$(dirname "$LOGFILE")"
-
-log()     { printf "${BLUE}[%s]${NC} %s\n" "$(date '+%Y-%m-%d %H:%M:%S')" "$1" | tee -a "$LOGFILE"; }
-success() { printf "${GREEN}✔ %s${NC}\n" "$1" | tee -a "$LOGFILE"; }
-warn()    { printf "${YELLOW}⚠ %s${NC}\n" "$1" | tee -a "$LOGFILE"; }
-error()   { printf "${RED}✖ %s${NC}\n" "$1" | tee -a "$LOGFILE" >&2; }
-
-INSTALL_MODE=""
-CHANNEL=""
-
-check_os() {
-    case "$(uname -s)" in
-        FreeBSD|OpenBSD|NetBSD|DragonFly) ;;
-        *) error "Only BSD systems (FreeBSD, OpenBSD, NetBSD, DragonFly) are supported by this script"; exit 1 ;;
-    esac
-}
-
-detect_target() {
-    local os arch
-    os="$(uname -s)"
-    arch="$(uname -m)"
-
-    case "$os:$arch" in
-        FreeBSD:x86_64|FreeBSD:amd64)      TARGET_TRIPLE="x86_64-unknown-freebsd" ;;
-        OpenBSD:x86_64|OpenBSD:amd64)      TARGET_TRIPLE="x86_64-unknown-openbsd" ;;
-        NetBSD:x86_64|NetBSD:amd64)        TARGET_TRIPLE="x86_64-unknown-netbsd" ;;
-        DragonFly:x86_64|DragonFly:amd64)  TARGET_TRIPLE="x86_64-unknown-dragonfly" ;;
-        *) error "Unsupported BSD platform: $os/$arch"; exit 1 ;;
-    esac
-}
-
-check_common_dependencies() {
-    command -v curl >/dev/null 2>&1 || { error "curl is not installed"; exit 1; }
-    if [ "$CHANNEL" = "dev" ]; then
-        if ! command -v python3 >/dev/null 2>&1 && ! command -v jq >/dev/null 2>&1; then
-            error "For dev installations, either 'python3' or 'jq' must be installed to parse GitHub API response."
-            exit 1
-        fi
-    fi
-}
-
-check_build_dependencies() {
-    command -v git   >/dev/null 2>&1 || { error "git is not installed"; exit 1; }
-    command -v cargo >/dev/null 2>&1 || { error "cargo is not installed"; exit 1; }
-}
-
-select_channel() {
-    echo "Choose channel:"
-    echo "  1) Latest stable release (default)"
-    echo "  2) Latest dev (pre-release)"
-    printf "Enter 1 or 2 [1]: "
-    read -r choice
-
-    case "${choice:-1}" in
-        1) CHANNEL="stable" ;;
-        2) CHANNEL="dev"    ;;
-        *) error "Unknown option"; exit 1 ;;
-    esac
-}
-
-select_install_mode() {
-    echo "Choose installation mode:"
-    echo "  1) Download prebuilt binary from GitHub Release (recommended)"
-    echo "  2) Build from git"
-    printf "Enter 1 or 2 [1]: "
-    read -r choice
-
-    case "${choice:-1}" in
-        1) INSTALL_MODE="release" ;;
-        2) INSTALL_MODE="build"   ;;
-        *) error "Unknown option"; exit 1 ;;
-    esac
-}
-
-fetch_release_json() {
-    if [ "$CHANNEL" = "dev" ]; then
-        log "Looking for latest dev (pre-release)..."
-        local json result
-        json="$(curl -fsSL "$GITHUB_API_ALL")"
-        if command -v jq >/dev/null 2>&1; then
-            result="$(printf '%s' "$json" | jq -e -c 'map(select(.prerelease == true))[0]')"
-        else
-            result="$(printf '%s' "$json" | python3 - <<'EOF'
-import sys, json
-releases = json.load(sys.stdin)
-pre = [r for r in releases if r.get("prerelease", False)]
-if not pre:
-    print("{}", end="")
-else:
-    print(json.dumps(pre[0]), end="")
-EOF
-)"
-        fi
-
-        if [ -z "$result" ] || [ "$result" = "{}" ] || [ "$result" = "null" ]; then
-            error "No dev (pre-release) found on GitHub"
-            exit 1
-        fi
-        printf '%s' "$result"
-    else
-        curl -fsSL "$GITHUB_API_LATEST"
-    fi
-}
-
-download_binary() {
-    local release_json tag version asset_name download_url
-
-    release_json="$(fetch_release_json)"
-
-    tag="$(printf '%s\n' "$release_json" | \
-        sed -n 's/.*"tag_name": "\([^"]*\)".*/\1/p' | head -n1)"
-    if [ -z "$tag" ]; then
-        error "Failed to determine release version"
-        exit 1
-    fi
-
-    version="${tag#v}"
-    asset_name="dcr-${TARGET_TRIPLE}-${version}"
-
-    log "Fetching release ${tag} (channel: ${CHANNEL})..."
-
-    download_url="$(printf '%s\n' "$release_json" | \
-        sed -n "s#.*\"browser_download_url\": \"\([^\"]*/${asset_name}\)\".*#\1#p" | head -n1)"
-
-    if [ -z "$download_url" ]; then
-        error "Asset ${asset_name} not found in release ${tag}"
-        exit 1
-    fi
-
-    mkdir -p "$INSTALL_PATH"
-    curl -fL "$download_url" -o "$INSTALL_PATH/dcr"
-    chmod +x "$INSTALL_PATH/dcr"
-    success "Binary ${asset_name} downloaded (${tag})"
-}
-
-prepare_sources() {
-    log "Fetching sources..."
-    rm -rf "$TMPDIR"
-    git clone --depth 1 "$REPO_URL" "$TMPDIR"
-    if [ "$CHANNEL" = "dev" ]; then
-        git clone --depth 1 --branch dev "$REPO_URL" "$TMPDIR" 2>/dev/null || \
-        git clone --depth 1 "$REPO_URL" "$TMPDIR"
-    fi
-    success "Sources fetched"
-}
-
-build_binary() {
-    log "Building release binary..."
-    (cd "$TMPDIR" && cargo build --release)
-    success "Build completed"
-}
-
-install_built_binary() {
-    mkdir -p "$INSTALL_PATH"
-    cp "$TMPDIR/target/release/dcr" "$INSTALL_PATH/dcr"
-    chmod +x "$INSTALL_PATH/dcr"
-    success "Binary installed from source"
-}
-
-install_link() {
-    log "Creating symlink..."
-    mkdir -p "$BINPATH"
-    ln -sf "$INSTALL_PATH/dcr" "$BINPATH/dcr"
-    success "Command 'dcr' added to $BINPATH"
-}
-
-check_path() {
-    if ! echo "$PATH" | grep -q "$BINPATH"; then
-        warn "Directory $BINPATH not found in PATH"
-        echo "Add this to ~/.bashrc, ~/.zshrc or ~/.profile:"
-        echo "export PATH=\"$BINPATH:\$PATH\""
-    fi
-}
-
-cleanup() {
-    rm -rf "$TMPDIR" 2>/dev/null || true
-}
-
-main() {
-    log "Starting DCR installation for BSD"
-
-    check_os
-    select_channel
-    check_common_dependencies
-    detect_target
-    select_install_mode
-    cleanup
-
-    if [ "$INSTALL_MODE" = "build" ]; then
-        check_build_dependencies
-        prepare_sources
-        build_binary
-        install_built_binary
-    else
-        download_binary
-    fi
-
-    install_link
-    check_path
-    cleanup
-
-    success "Installation completed successfully"
-    log "Log saved to $LOGFILE"
-}
-
-main "$@"

man/man1/dcr-add.1

@@ -0,0 +1,42 @@
+.TH DCR-ADD 1 "2026-06-02" "dcr 0.7.0" "DCR Manual"
+.SH NAME
+dcr-add \- Add a dependency to a DCR project
+.SH SYNOPSIS
+.B dcr add \fI<name>\fR \fI<source>\fR
+[\fB\-\-branch\fR \fI<b>\fR]
+[\fB\-\-tag\fR \fI<t>\fR]
+[\fB\-\-rev\fR \fI<r>\fR]
+.SH DESCRIPTION
+Adds a dependency to the project.
+.SH SOURCES
+.TP
+.B user/repo
+GitHub shorthand.
+.TP
+.B github:user/repo
+Full GitHub repository.
+.TP
+.B gitlab:user/repo
+GitLab repository.
+.TP
+.B git:host.com/user/repo
+Generic git repository.
+.TP
+.B path:./path/to/lib
+Local path dependency.
+.TP
+.B <version>
+Version from registry.
+.SH OPTIONS
+.TP
+.B \-\-branch \fI<name>\fR
+Use a specific branch.
+.TP
+.B \-\-tag \fI<name>\fR
+Use a specific tag.
+.TP
+.B \-\-rev \fI<hash>\fR
+Use a specific commit hash.
+.SH SEE ALSO
+.BR dcr (1),
+.BR dcr-tree (1)

man/man1/dcr-build.1

@@ -0,0 +1,48 @@
+.TH DCR-BUILD 1 "2026-08-04" "dcr 0.8.4" "DCR Manual"
+.SH NAME
+dcr-build \- Compile a DCR project
+.SH SYNOPSIS
+.B dcr build
+[\fB\-\-debug\fR | \fB\-\-release\fR]
+[\fB\-\-target\fR \fI<triple>\fR]
+[\fB\-\-force\fR]
+[\fB\-\-clean\fR]
+[\fB\-\-verbose\fR]
+[\fB\-\-workspace\fR \fI<name>\fR]
+[\fB\-\-print\-artifact\-path\fR]
+.SH DESCRIPTION
+Compiles the project. Default profile is
+.B \-\-debug .
+On success, updates
+.B .dcr/build-info.json
+and
+.B .dcr/toolchain.json
+when applicable.
+.SH OPTIONS
+.TP
+.B \-\-debug
+Build with debug profile (default). Enables debug symbols.
+.TP
+.B \-\-release
+Build with release profile. Enables full optimization.
+.TP
+.B \-\-target \fI<triple>\fR
+Cross-compile for the given target.
+.TP
+.B \-\-force
+Force a full rebuild, ignoring cached artifacts.
+.TP
+.B \-\-clean
+Clean before building.
+.TP
+.B \-\-verbose
+Print detailed build output including compiler commands.
+.TP
+.B \-\-workspace \fI<name>\fR
+Build a specific workspace member.
+.TP
+.B \-\-print\-artifact\-path
+After a successful build, print the absolute path of the main artifact as a single line on stdout.
+.SH SEE ALSO
+.BR dcr (1),
+.BR dcr-gen (1)

man/man1/dcr-clean.1

@@ -0,0 +1,26 @@
+.TH DCR-CLEAN 1 "2026-06-02" "dcr 0.7.0" "DCR Manual"
+.SH NAME
+dcr-clean \- Remove build artifacts
+.SH SYNOPSIS
+.B dcr clean
+[\fB\-\-debug\fR | \fB\-\-release\fR]
+[\fB\-\-target\fR \fI<triple>\fR]
+[\fB\-\-all\fR]
+.SH DESCRIPTION
+Removes build artifacts from the target directory.
+.SH OPTIONS
+.TP
+.B \-\-debug
+Clean debug artifacts (default).
+.TP
+.B \-\-release
+Clean release artifacts.
+.TP
+.B \-\-target \fI<triple>\fR
+Clean artifacts for a specific target.
+.TP
+.B \-\-all
+Clean all workspace members.
+.SH SEE ALSO
+.BR dcr (1),
+.BR dcr-build (1)

man/man1/dcr-fmt.1

@@ -0,0 +1,10 @@
+.TH DCR-FMT 1 "2026-06-02" "dcr 0.7.0" "DCR Manual"
+.SH NAME
+dcr-fmt \- Format C/C++ source files
+.SH SYNOPSIS
+.B dcr fmt
+.SH DESCRIPTION
+Formats all C/C++ source files using clang-format. Scans \fBsrc/\fR
+and \fBtests/\fR directories recursively.
+.SH SEE ALSO
+.BR dcr (1)

man/man1/dcr-gen.1

@@ -0,0 +1,67 @@
+.TH DCR-GEN 1 "2026-08-04" "dcr 0.8.4" "DCR Manual"
+.SH NAME
+dcr-gen \- Generate IDE and tooling integration files
+.SH SYNOPSIS
+.B dcr gen \fI<subcommand>\fR
+[\fB\-\-debug\fR | \fB\-\-release\fR]
+[\fB\-\-quiet\fR | \fB\-q\fR]
+.SH DESCRIPTION
+Generates IDE and tooling integration files for DCR projects.
+Machine-readable build facts are written under
+.B .dcr/
+(compile database, build-info, toolchain).
+.SH SUBCOMMANDS
+.TP
+.B project-info
+Print project metadata as JSON to stdout (absolute paths, artifact_path, target_dir).
+Also updates
+.B .dcr/build-info.json
+and
+.B .dcr/toolchain.json .
+.TP
+.B compile-commands
+Generate
+.B .dcr/compile_commands.json
+(atomic write) and ensure
+.B .clangd
+points at
+.B .dcr
+as CompilationDatabase.
+.TP
+.B vscode
+Generate
+.B .vscode/
+integration files (tasks, launch configurations) and compile commands under
+.B .dcr/ .
+.TP
+.B clion
+Generate
+.B .idea/
+integration files for CLion and compile commands under
+.B .dcr/ .
+.SH OPTIONS
+.TP
+.B \-\-debug
+Use debug profile (default).
+.TP
+.B \-\-release
+Use release profile.
+.TP
+.B \-\-quiet\fR, \fB\-q
+Suppress human-readable success messages on stdout.
+.SH FILES
+.TP
+.B .dcr/compile_commands.json
+JSON Compilation Database (moved from project root; breaking change in 0.8.4).
+.TP
+.B .dcr/build-info.json
+Last known artifact path, profile, compiler.
+.TP
+.B .dcr/toolchain.json
+Resolved compiler/debugger (and Qt tools if configured).
+.TP
+.B .clangd
+Created once with CompilationDatabase: .dcr; not overwritten if customized.
+.SH SEE ALSO
+.BR dcr (1),
+.BR dcr-build (1)

man/man1/dcr-init.1

@@ -0,0 +1,11 @@
+.TH DCR-INIT 1 "2026-06-02" "dcr 0.7.0" "DCR Manual"
+.SH NAME
+dcr-init \- Initialize a directory as a DCR project
+.SH SYNOPSIS
+.B dcr init
+.SH DESCRIPTION
+Initializes the current directory as a DCR project. The directory must
+be empty.
+.SH SEE ALSO
+.BR dcr (1),
+.BR dcr-new (1)

man/man1/dcr-new.1

@@ -0,0 +1,13 @@
+.TH DCR-NEW 1 "2026-06-02" "dcr 0.7.0" "DCR Manual"
+.SH NAME
+dcr-new \- Create a new DCR project
+.SH SYNOPSIS
+.B dcr new \fI<name>\fR
+.SH DESCRIPTION
+Creates a new C/C++ project with the given name. The name may only
+contain ASCII letters, digits, underscores and hyphens.
+.SH EXAMPLE
+.B dcr new my-project
+.SH SEE ALSO
+.BR dcr (1),
+.BR dcr-init (1)

man/man1/dcr-run.1

@@ -0,0 +1,47 @@
+.TH DCR-RUN 1 "2026-06-02" "dcr 0.7.0" "DCR Manual"
+.SH NAME
+dcr-run \- Build and run a DCR project
+.SH SYNOPSIS
+.B dcr run
+[\fB\-\-debug\fR | \fB\-\-release\fR]
+[\fB\-\-target\fR \fI<triple>\fR]
+[\fB\-\-force\fR]
+[\fB\-\-clean\fR]
+[\fB\-\-verbose\fR]
+[\fB\-\-\fR \fI<args>...\fR]
+.SH DESCRIPTION
+Builds and runs the project. Only available for projects with
+\fBkind = "bin"\fR.
+Arguments after a bare
+.B \-\-
+are forwarded to the built binary (cargo-style).
+.SH OPTIONS
+.TP
+.B \-\-debug
+Run with debug profile (default).
+.TP
+.B \-\-release
+Run with release profile.
+.TP
+.B \-\-target \fI<triple>\fR
+Cross-compile for the given target.
+.TP
+.B \-\-force
+Force a full rebuild.
+.TP
+.B \-\-clean
+Clean before building.
+.TP
+.B \-\-verbose
+Print detailed build output.
+.TP
+.B \-\- \fI<args>...\fR
+Arguments passed to the built binary.
+.SH EXAMPLES
+.nf
+dcr run --release -- --test_help
+dcr run -- --foo bar
+.fi
+.SH SEE ALSO
+.BR dcr (1),
+.BR dcr-build (1)

man/man1/dcr-setup.1

@@ -0,0 +1,11 @@
+.TH DCR-SETUP 1 "2026-06-02" "dcr 0.7.0" "DCR Manual"
+.SH NAME
+dcr-setup \- Set up DCR registries
+.SH SYNOPSIS
+.B dcr setup
+.SH DESCRIPTION
+Sets up DCR registries. Downloads and indexes package registries
+for dependency resolution.
+.SH SEE ALSO
+.BR dcr (1),
+.BR dcr-add (1)

man/man1/dcr-test.1

@@ -0,0 +1,24 @@
+.TH DCR-TEST 1 "2026-06-02" "dcr 0.7.0" "DCR Manual"
+.SH NAME
+dcr-test \- Run project tests
+.SH SYNOPSIS
+.B dcr test
+[\fB\-\-init\fR]
+[\fB\-\-debug\fR | \fB\-\-release\fR]
+.SH ALIASES
+.B dcr tests
+.SH DESCRIPTION
+Runs project tests and prints a unified testsuite report.
+.SH OPTIONS
+.TP
+.B \-\-init
+Create \fBtests/dcr_test.h\fR in the current project.
+.TP
+.B \-\-debug
+Build and run tests with debug profile (default).
+.TP
+.B \-\-release
+Build and run tests with release profile.
+.SH SEE ALSO
+.BR dcr (1),
+.BR dcr-build (1)

man/man1/dcr-tree.1

@@ -0,0 +1,11 @@
+.TH DCR-TREE 1 "2026-06-02" "dcr 0.7.0" "DCR Manual"
+.SH NAME
+dcr-tree \- Display the dependency tree
+.SH SYNOPSIS
+.B dcr tree
+.SH DESCRIPTION
+Displays the dependency tree of the current project, showing all
+transitive dependencies and their versions.
+.SH SEE ALSO
+.BR dcr (1),
+.BR dcr-add (1)

man/man1/dcr.1

@@ -0,0 +1,212 @@
+.TH DCR 1 "2026-06-02" "dcr 0.7.0" "DCR Manual"
+.SH NAME
+dcr \- Cargo\-like build tool and package manager for C/C++ projects
+.SH SYNOPSIS
+.B dcr
+[\fIcommand\fR] [\fIoptions\fR]
+.SH DESCRIPTION
+DCR is a comprehensive build tool and package manager for C and C++ projects,
+inspired by Cargo from the Rust ecosystem. It handles project creation,
+building, dependency management, testing, formatting, and IDE integration.
+.SH COMMANDS
+.TP
+.B new \fI<name>\fR
+Create a new C/C++ project with the given name. Only ASCII letters, digits,
+underscores and hyphens are allowed.
+.TP
+.B init
+Initialize the current (empty) directory as a DCR project.
+.TP
+.B build [\fIoptions\fR]
+Compile the project. Default profile is \fB\-\-debug\fR.
+.TP
+.B run [\fIoptions\fR]
+Build and run the project. Only available for binary projects.
+.TP
+.B clean [\fIoptions\fR]
+Remove build artifacts from the target directory.
+.TP
+.B test [\fI\-\-init\fR] [\fI\-\-debug\fR|\fI\-\-release\fR]
+Run project tests (alias: \fBdcr tests\fR).
+.TP
+.B add \fI<name>\fR \fI<source>\fR [\fIoptions\fR]
+Add a dependency to the project.
+.TP
+.B tree
+Display the dependency tree of the current project.
+.TP
+.B fmt
+Format all C/C++ source files using clang-format.
+.TP
+.B lint [\fI\-\-fix\fR]
+Run clang-tidy static analysis on C/C++ sources.
+.TP
+.B gen \fI<subcommand>\fR
+Generate IDE integration files (vscode, clion, compile-commands, project-info).
+.TP
+.B setup
+Show configured package registries.
+.SH GLOBAL FLAGS
+.TP
+.B \-\-help
+Show this help message and exit.
+.TP
+.B \-\-version
+Print version information and exit.
+.TP
+.B \-\-update
+Update DCR to the latest version from GitHub Releases.
+.SH BUILD OPTIONS
+The following options apply to \fBbuild\fR and \fBrun\fR commands:
+.TP
+.B \-\-debug
+Build with debug profile (default). Enables debug symbols and minimal optimization.
+.TP
+.B \-\-release
+Build with release profile. Enables full optimization without debug symbols.
+.TP
+.B \-\-target \fI<triple>\fR
+Cross-compile for the given target (e.g. \fBaarch64-linux-gnu\fR, \fBx86_64-w64-mingw32\fR).
+Short names like \fBlinux\fR, \fBmacos\fR, \fBwindows\fR are also supported.
+.TP
+.B \-\-force
+Force a full rebuild, ignoring cached build artifacts.
+.TP
+.B \-\-clean
+Clean build artifacts before building.
+.TP
+.B \-\-verbose
+Print detailed build output including compiler commands.
+.TP
+.B \-\-workspace \fI<name>\fR
+Build a specific workspace member.
+.SH CLEAN OPTIONS
+.TP
+.B \-\-debug
+Clean debug artifacts (default).
+.TP
+.B \-\-release
+Clean release artifacts.
+.TP
+.B \-\-target \fI<triple>\fR
+Clean artifacts for a specific target.
+.TP
+.B \-\-all
+Clean all workspace members.
+.SH ADD OPTIONS
+.TP
+.B \-\-branch \fI<name>\fR
+Use a specific branch when adding a git dependency.
+.TP
+.B \-\-tag \fI<name>\fR
+Use a specific tag when adding a git dependency.
+.TP
+.B \-\-rev \fI<hash>\fR
+Use a specific commit hash when adding a git dependency.
+.SH DEPENDENCY SOURCES
+.TP
+.B user/repo
+GitHub shorthand (e.g. \fBuser/repo\fR).
+.TP
+.B github:user/repo
+Full GitHub repository URL shorthand.
+.TP
+.B gitlab:user/repo
+GitLab repository URL shorthand.
+.TP
+.B git:host.com/user/repo
+Generic git repository.
+.TP
+.B path:./path/to/lib
+Local path dependency.
+.TP
+.B \fI<version>\fR
+Version from registry (e.g. \fB1.2.3\fR).
+.SH GEN SUBCOMMANDS
+.TP
+.B project-info
+Print project metadata as JSON to stdout.
+.TP
+.B compile-commands
+Generate \fB.dcr/compile_commands.json\fR for IDE tooling.
+.TP
+.B vscode
+Generate \fB.vscode/\fR integration files (tasks, launch configurations).
+.TP
+.B clion
+Generate \fB.idea/\fR integration files for CLion.
+.SH TEST OPTIONS
+.TP
+.B \-\-init
+Create \fBtests/dcr_test.h\fR in the current project.
+.TP
+.B \-\-debug
+Build and run tests with debug profile (default).
+.TP
+.B \-\-release
+Build and run tests with release profile.
+.SH PROJECT CONFIGURATION
+DCR uses \fBdcr.toml\fR for project configuration. Key settings include:
+.TP
+.B package.name
+Project name (required).
+.TP
+.B package.version
+Project version (default: \fB0.1.0\fR).
+.TP
+.B package.dcr\-version
+Semver of the DCR tool this project targets. Set automatically by
+\fBdcr new\fR / \fBdcr init\fR. Missing pin, or an installed \fBdcr\fR older/newer
+than the pin, prints a warning (commands still run).
+.TP
+.B build.language
+Programming language: \fBc\fR or \fBc++\fR (default: \fBc\fR).
+.TP
+.B build.standard
+Language standard (e.g. \fBc11\fR, \fBc17\fR, \fBc++20\fR; default: \fBc11\fR).
+.TP
+.B build.compiler
+Compiler to use: \fBclang\fR, \fBgcc\fR, \fBcl\fR, \fBclang-cl\fR (default: \fBclang\fR).
+.TP
+.B build.kind
+Output type: \fBbin\fR, \fBlib\fR (static or dynamic), \fBstaticlib\fR, \fBsharedlib\fR (default: \fBbin\fR).
+.SH FILES
+.TP
+.I dcr.toml
+Project manifest file.
+.TP
+.I ~/.dcr/config.toml
+User-level DCR configuration.
+.TP
+.I ~/.dcr/index.json
+Local registry index.
+.SH ENVIRONMENT
+.TP
+.B DCR_COMPILER
+Override the compiler used for building.
+.TP
+.B DCR_CC
+Alternative way to override the compiler.
+.SH EXAMPLES
+.TP
+Create a new project:
+.B dcr new hello
+.TP
+Initialize from current directory:
+.B dcr init
+.TP
+Build with release profile:
+.B dcr build \-\-release
+.TP
+Cross-compile for Windows:
+.B dcr build \-\-target windows
+.TP
+Add a dependency:
+.BR "dcr add curl git:https://github.com/curl/curl" .
+.TP
+Generate VS Code integration:
+.B dcr gen vscode
+.SH SEE ALSO
+.IR https://dcr.dexoron.su ", " https://github.com/dexoron/dcr
+.SH AUTHORS
+Dexoron (Bezotechestvo Vladimir) <main@dexoron.su>

packaging/aur/dcr/PKGBUILD

@@ -27,4 +27,7 @@ package() {
   cd "$srcdir/$pkgname-$pkgver"
   install -Dm755 "target/release/dcr" "$pkgdir/usr/bin/dcr"
   install -Dm644 LICENSE "$pkgdir/usr/share/licenses/$pkgname/LICENSE"
+  for manpage in man/man1/*.1; do
+    install -Dm644 "$manpage" "$pkgdir/usr/share/man/man1/$(basename "$manpage")"
+  done
 }

scripts/sync-releases-to-gitlab.py

@@ -1,192 +0,0 @@
-#!/usr/bin/env python3
-"""Sync all GitHub Releases (with assets) to GitLab Releases."""
-
-import json
-import os
-import sys
-import time
-import urllib.error
-import urllib.request
-import uuid
-
-GL_TOKEN = os.environ.get("GL_TOKEN")
-if not GL_TOKEN:
-    print("FATAL: GL_TOKEN environment variable not set", file=sys.stderr)
-    sys.exit(1)
-
-GL_PROJECT = "dexoron-studio%2Fdcr"
-GL_PROJECT_RAW = "dexoron-studio/dcr"
-GL_API = "https://gitlab.com/api/v4"
-GH_REPO = "dexoron/dcr"
-
-
-def gl_api(method, path, data=None, filepath=None, retries=5):
-    url = f"{GL_API}/{path}"
-    headers = {"PRIVATE-TOKEN": GL_TOKEN}
-
-    if data is not None and filepath is None:
-        headers["Content-Type"] = "application/json"
-        body = json.dumps(data).encode()
-    elif filepath:
-        boundary = uuid.uuid4().hex
-        with open(filepath, "rb") as f:
-            fdata = f.read()
-        fname = os.path.basename(filepath)
-        parts = []
-        parts.append(f"--{boundary}".encode())
-        parts.append(f'Content-Disposition: form-data; name="file"; filename="{fname}"'.encode())
-        parts.append(b"Content-Type: application/octet-stream")
-        parts.append(b"")
-        parts.append(fdata)
-        parts.append(f"--{boundary}--".encode())
-        parts.append(b"")
-        body = b"\r\n".join(parts)
-        headers["Content-Type"] = f"multipart/form-data; boundary={boundary}"
-    else:
-        body = None
-
-    for attempt in range(retries):
-        try:
-            req = urllib.request.Request(url, data=body, headers=headers, method=method)
-            with urllib.request.urlopen(req) as resp:
-                text = resp.read().decode()
-                return json.loads(text) if text else None
-        except urllib.error.HTTPError as e:
-            body_text = e.read().decode() if e.fp else ""
-            if e.code in (409, 429) and attempt < retries - 1:
-                time.sleep(3)
-                continue
-            if attempt < retries - 1:
-                time.sleep(1)
-                continue
-            print(f"  HTTP {e.code}: {body_text[:300]}", file=sys.stderr)
-            return None
-        except Exception as e:
-            if attempt < retries - 1:
-                time.sleep(1)
-                continue
-            print(f"  Error: {e}", file=sys.stderr)
-            return None
-    return None
-
-
-def download_file(url, dest):
-    with urllib.request.urlopen(url) as resp:
-        with open(dest, "wb") as f:
-            f.write(resp.read())
-
-
-# --- MAIN ---
-print("Fetching GitHub releases...")
-with urllib.request.urlopen(f"https://api.github.com/repos/{GH_REPO}/releases?per_page=50") as r:
-    gh_releases = json.loads(r.read().decode())
-
-print(f"Found {len(gh_releases)} releases on GitHub")
-
-# Reverse to process oldest first (GitHub returns newest first)
-gh_releases.reverse()
-
-print("Fetching existing GitLab releases and their assets...")
-existing = gl_api("GET", f"projects/{GL_PROJECT}/releases?per_page=100") or []
-existing = existing if isinstance(existing, list) else []
-
-# Build map: tag -> set of existing asset names
-gl_assets = {}
-for rel in existing:
-    tag = rel["tag_name"]
-    links = rel.get("assets", {}).get("links", []) or rel.get("assets", {}).get("sources", []) or []
-    gl_assets[tag] = {l.get("name", "") for l in links if isinstance(l, dict)}
-    # Also get the release description to check if it needs updating
-    gl_assets[tag + "__desc"] = rel.get("description", "")
-
-print(f"Existing GitLab releases: {len(existing)}")
-
-download_dir = "/tmp/gh-assets"
-os.makedirs(download_dir, exist_ok=True)
-
-# Reverse: process older first so newer releases with many assets get their description too
-# Actually, process in original order
-total = len(gh_releases)
-for i, rel in enumerate(gh_releases):
-    tag = rel["tag_name"]
-    body = rel.get("body", "") or ""
-    assets = rel.get("assets", [])
-    if isinstance(assets, dict):
-        assets = assets.get("nodes", []) or []
-
-    print(f"\n{'='*60}")
-    print(f"[{i+1}/{total}] {tag} ({len(assets)} assets)")
-
-    # Create or update release
-    existing_tag = tag in gl_assets
-    if not existing_tag:
-        print(f"  Creating release...")
-        result = gl_api("POST", f"projects/{GL_PROJECT}/releases", data={
-            "tag_name": tag,
-            "name": rel.get("name", tag),
-            "description": body,
-            "ref": "master",
-        })
-        if result is None:
-            print(f"  FAILED — skip")
-            continue
-        print(f"  OK")
-    else:
-        # Update description if needed
-        existing_desc = gl_assets.get(tag + "__desc", "")
-        if body and body != existing_desc:
-            print(f"  Updating description...")
-            gl_api("PUT", f"projects/{GL_PROJECT}/releases/{urllib.request.quote(tag, safe='')}",
-                   data={"description": body})
-
-    existing_links = gl_assets.get(tag, set())
-
-    for j, asset in enumerate(assets):
-        aname = asset.get("name", "")
-        aurl = asset.get("browser_download_url", "")
-        if not aurl:
-            continue
-
-        if aname in existing_links:
-            print(f"  [{j+1}/{len(assets)}] {aname} — already exists")
-            continue
-
-        fpath = os.path.join(download_dir, aname)
-        print(f"  [{j+1}/{len(assets)}] {aname}...", end=" ", flush=True)
-
-        # Download from GitHub
-        try:
-            download_file(aurl, fpath)
-        except Exception as e:
-            print(f"download failed: {e}")
-            continue
-
-        # Upload to GitLab
-        up = gl_api("POST", f"projects/{GL_PROJECT}/uploads", filepath=fpath)
-        if not up or "url" not in up:
-            size_mb = os.path.getsize(fpath) / (1024 * 1024)
-            print(f"upload failed ({size_mb:.1f} MB)")
-            os.remove(fpath)
-            continue
-
-        file_url = up["url"]
-        full_url = f"https://gitlab.com/{GL_PROJECT_RAW}{file_url}"
-
-        # Link asset to release
-        encoded_tag = urllib.request.quote(tag, safe='')
-        link = gl_api("POST",
-            f"projects/{GL_PROJECT}/releases/{encoded_tag}/assets/links",
-            data={"name": aname, "url": full_url},
-            retries=5)
-        if link:
-            print(f"linked")
-            existing_links.add(aname)
-        else:
-            print(f"link failed")
-
-        os.remove(fpath)
-
-    time.sleep(0.3)
-
-print(f"\n{'='*60}")
-print("Done!")

src/cli/add.rs

@@ -15,25 +15,71 @@
 // You should have received a copy of the GNU General Public License
 // along with this program.  If not, see <https://www.gnu.org/licenses/>.
 
-use crate::core::config::Config;
+use crate::core::build_config::Config;
 use crate::core::deps::register;
 use crate::utils::fs::find_project_root;
 use crate::utils::log::error;
-use crate::utils::text::{BOLD_GREEN, colored};
+use crate::utils::text::{BOLD_CYAN, BOLD_GREEN, colored, printc};
 use toml::Value;
 use toml::map::Map;
 
+/// Parsed arguments for the `dcr add` command.
+///
+/// Exactly one of `path`, `git`, or `version_from_registry` is expected to be set,
+/// depending on how the dependency source was specified.
 pub struct AddArgs {
+    /// Dependency name as it will appear under `[dependencies]` in `dcr.toml`.
     pub name: String,
+    /// Local filesystem path when the source uses the `path:` prefix.
     pub path: Option<String>,
+    /// Git repository URL when the source is a git/GitHub/GitLab URL or prefix.
     pub git: Option<String>,
+    /// Optional git branch to pin the dependency to.
     pub branch: Option<String>,
+    /// Optional git tag to pin the dependency to.
     pub tag: Option<String>,
+    /// Optional git commit hash (revision) to pin the dependency to.
     pub rev: Option<String>,
+    /// Version string resolved from the package registry when no explicit source is given.
     pub version_from_registry: Option<String>,
 }
 
+/// Adds a dependency to the current project's `dcr.toml`.
+///
+/// Parses CLI arguments, locates the project root, builds a TOML dependency value
+/// (path, git with optional ref, or registry version), and writes it under
+/// `dependencies.<name>`.
+///
+/// # Parameters
+/// - `args`: Tokens after `dcr add` (name, source, optional `--branch`/`--tag`/`--rev`).
+///
+/// # Returns
+/// Process exit code: `0` on success, non-zero on usage or I/O errors.
 pub fn add(args: &[String]) -> i32 {
+    if args.first().is_some_and(|a| a == "--help") {
+        printc("USAGE:", BOLD_GREEN);
+        printc(
+            "    dcr add <name> <source> [--branch <b>] [--tag <t>] [--rev <r>]",
+            BOLD_CYAN,
+        );
+        println!();
+        printc("DESCRIPTION:", BOLD_GREEN);
+        println!("    Adds a dependency to the project.");
+        println!();
+        printc("SOURCES:", BOLD_GREEN);
+        println!("    github:user/repo          GitHub repository");
+        println!("    gitlab:user/repo          GitLab repository");
+        println!("    git:host.com/user/repo    Generic git repository");
+        println!("    path:./path/to/lib        Local path dependency");
+        println!("    <version>                 Version from registry");
+        println!();
+        printc("OPTIONS:", BOLD_GREEN);
+        println!("    --branch <b>    Use a specific branch");
+        println!("    --tag <t>       Use a specific tag");
+        println!("    --rev <r>       Use a specific commit hash");
+        return 0;
+    }
+
     let add_args = match parse_add_args(args) {
         Ok(a) => a,
         Err(code) => return code,
@@ -67,6 +113,7 @@ pub fn add(args: &[String]) -> i32 {
         }
     };
 
+    // Build the TOML value written under dependencies.<name>
     let dep_value = if let Some(git_url) = add_args.git {
         if add_args.branch.is_none() && add_args.tag.is_none() && add_args.rev.is_none() {
             let mut table = Map::new();
@@ -111,11 +158,15 @@ pub fn add(args: &[String]) -> i32 {
     0
 }
 
+/// Parses CLI arguments into an [`AddArgs`] value.
+///
+/// Expects `<name> [source] [--branch|--tag|--rev ...]`. If `source` is omitted,
+/// the package registry is queried for a default version. Source strings may use
+/// `path:`, `github:`, `gitlab:`, or `git:` prefixes, or a full git URL.
 fn parse_add_args(args: &[String]) -> Result<AddArgs, i32> {
     if args.is_empty() {
         error("Usage: dcr add <name> <source> [--branch <branch> | --tag <tag> | --rev <rev>]");
         error("Sources:");
-        error("  user/repo                 -> github.com/user/repo");
         error("  github:user/repo          -> github.com/user/repo");
         error("  gitlab:user/repo          -> gitlab.com/user/repo");
         error("  git:host.com/user/repo    -> host.com/user/repo");
@@ -145,7 +196,7 @@ fn parse_add_args(args: &[String]) -> Result<AddArgs, i32> {
         }
         source_spec = s.clone();
     } else {
-        // No source provided — try registry auto-lookup
+        // No source provided — resolve version from the package registry
         match register::resolve_package_from_registry(&name) {
             Ok(info) => {
                 let version = info
@@ -212,6 +263,7 @@ fn parse_add_args(args: &[String]) -> Result<AddArgs, i32> {
     let mut path = None;
     let mut git = None;
 
+    // Map source prefixes / bare URLs to path or git fields
     if let Some(p) = source_spec.strip_prefix("path:") {
         path = Some(p.to_string());
     } else if let Some(g) = source_spec.strip_prefix("github:") {
@@ -220,10 +272,10 @@ fn parse_add_args(args: &[String]) -> Result<AddArgs, i32> {
         git = Some(format!("https://gitlab.com/{}", g));
     } else if let Some(g) = source_spec.strip_prefix("git:") {
         if g.contains('/') && !g.contains('.') {
-            // git:user/repo -> default to github
+            // git:user/repo with no host — default to GitHub
             git = Some(format!("https://github.com/{}", g));
         } else {
-            // git:host.com/user/repo
+            // git:host.com/user/repo or an already-qualified URL
             let url = if g.starts_with("http") || g.starts_with("git@") {
                 g.to_string()
             } else {
@@ -236,8 +288,15 @@ fn parse_add_args(args: &[String]) -> Result<AddArgs, i32> {
         || source_spec.starts_with("git@")
     {
         git = Some(source_spec);
+    } else if source_spec.starts_with("./")
+        || source_spec.starts_with("../")
+        || std::path::Path::new(&source_spec).is_absolute()
+    {
+        path = Some(source_spec);
     } else {
-        error("Source must have a prefix (path:, git:, github:, gitlab:) or be a full URL");
+        error(
+            "Source must be a path, a prefixed source (path:, git:, github:, gitlab:), or a full URL",
+        );
         return Err(1);
     }
 

src/cli/clean.rs

@@ -15,18 +15,44 @@
 // You should have received a copy of the GNU General Public License
 // along with this program.  If not, see <https://www.gnu.org/licenses/>.
 
-use crate::config::flags;
+use crate::core::build_config::Config;
-use crate::core::config::Config;
 use crate::core::workspace::parse_workspace;
-use crate::utils::build::parse_version_info;
+use crate::utils::build::{default_profile_flags, default_target_triple, parse_version_info};
 use crate::utils::fs::{check_dir, find_project_root, with_dir};
 use crate::utils::log::{error, warn};
-use crate::utils::text::{BOLD_GREEN, colored};
+use crate::utils::text::{BOLD_CYAN, BOLD_GREEN, colored, printc};
 use glob::glob;
 use std::fs;
 use std::path::Path;
 
+/// Entry point for the `dcr clean` command.
+///
+/// Removes build artifacts from the project (and optionally workspace members).
+///
+/// # Parameters
+/// - `args`: Tokens after `dcr clean` (`--debug`/`--release`, `--target`, `--all`).
+///
+/// # Returns
+/// Process exit code: `0` on success, `1` on failure.
 pub fn clean(args: &[String]) -> i32 {
+    if args.first().is_some_and(|a| a == "--help") {
+        printc("USAGE:", BOLD_GREEN);
+        printc(
+            "    dcr clean [--debug | --release] [--target <triple>] [--all]",
+            BOLD_CYAN,
+        );
+        println!();
+        printc("DESCRIPTION:", BOLD_GREEN);
+        println!("    Removes build artifacts from the target directory.");
+        println!();
+        printc("OPTIONS:", BOLD_GREEN);
+        println!("    --debug              Clean debug artifacts (default)");
+        println!("    --release            Clean release artifacts");
+        println!("    --target <triple>    Clean artifacts for a specific target");
+        println!("    --all                Clean all workspace members");
+        return 0;
+    }
+
     let start_dir = match std::env::current_dir() {
         Ok(dir) => dir,
         Err(_) => {
@@ -53,6 +79,7 @@ pub fn clean(args: &[String]) -> i32 {
         }
     };
 
+    // Run cleanup relative to the project root so paths resolve consistently.
     match with_dir(&root, || clean_from_root(&root, &flags)) {
         Ok(()) => 0,
         Err(msg) => {
@@ -62,12 +89,20 @@ pub fn clean(args: &[String]) -> i32 {
     }
 }
 
+/// Parsed flags controlling which artifacts `clean` should remove.
 struct CleanFlags {
+    /// Optional build profile name (e.g. `debug`, `release`).
     profile: Option<String>,
+    /// Optional target triple to clean under `target/<triple>/...`.
     target: Option<String>,
+    /// When true, also clean each workspace member that has a `target` directory.
     all: bool,
 }
 
+/// Parses CLI arguments into [`CleanFlags`].
+///
+/// Recognizes `--all`, `--target <triple>`, and profile flags such as `--debug`
+/// / `--release` (validated via [`default_profile_flags`]).
 fn parse_clean_flags(args: &[String]) -> Result<CleanFlags, String> {
     let mut profile: Option<String> = None;
     let mut target: Option<String> = None;
@@ -87,8 +122,9 @@ fn parse_clean_flags(args: &[String]) -> Result<CleanFlags, String> {
             continue;
         }
         if arg.starts_with("--") {
+            // Accept only known profile names (e.g. debug/release), not arbitrary flags.
             let candidate = arg.trim_start_matches("--").to_string();
-            if flags(&candidate).is_some() {
+            if !default_profile_flags(&candidate).is_empty() {
                 if profile.is_some() {
                     return Err("Duplicate profile flag".to_string());
                 }
@@ -105,41 +141,35 @@ fn parse_clean_flags(args: &[String]) -> Result<CleanFlags, String> {
     })
 }
 
+/// Cleans the project at `root`, and optionally all workspace members.
+///
+/// Resolves the effective target triple from flags, `dcr.toml`, or host defaults,
+/// then removes the appropriate `target` subdirectories and custom clean paths.
 fn clean_from_root(root: &Path, flags: &CleanFlags) -> Result<(), String> {
     let config = Config::open("./dcr.toml").map_err(|err| err.to_string())?;
 
-    let target = flags
+    // Prefer CLI --target, then build.target from config, then host defaults on Linux/BSD.
-        .target
+    let target = flags.target.clone().or_else(|| {
-        .clone()
+        config
-        .or_else(|| {
+            .get("build.target")
-            config
+            .and_then(|v| v.as_str())
-                .get("build.target")
+            .map(|s| s.trim().to_string())
-                .and_then(|v| v.as_str())
+            .filter(|s| !s.is_empty())
-                .map(|s| s.trim().to_string())
+    });
-                .filter(|s| !s.is_empty())
+    let target = match target {
-        })
+        Some(t) => Some(crate::utils::build::normalize_target_os(&t).to_string()),
-        .or_else(|| {
+        None if cfg!(target_os = "linux")
-            Some(if cfg!(target_os = "linux") {
+            || cfg!(any(
-                format!("{}-unknown-linux-gnu", std::env::consts::ARCH)
-            } else if cfg!(target_os = "macos") {
-                "x86_64-apple-darwin".to_string()
-            } else if cfg!(target_os = "windows") {
-                "x86_64-pc-windows-msvc".to_string()
-            } else if cfg!(any(
                 target_os = "freebsd",
                 target_os = "openbsd",
                 target_os = "netbsd",
                 target_os = "dragonfly"
-            )) {
+            )) =>
-                format!(
+        {
-                    "{}-unknown-{}",
+            Some(default_target_triple())
-                    std::env::consts::ARCH,
+        }
-                    std::env::consts::OS
+        None => None,
-                )
+    };
-            } else {
-                "unknown".to_string()
-            })
-        });
 
     if flags.all
         && let Some(workspace) = parse_workspace(
@@ -150,12 +180,21 @@ fn clean_from_root(root: &Path, flags: &CleanFlags) -> Result<(), String> {
         )?
     {
         for member in &workspace.members {
-            clean_project_at(&member.path, flags.profile.as_deref(), target.as_deref())?;
+            let member_target = member.path.join("target");
+            if member_target.is_dir() {
+                clean_project_at(&member.path, flags.profile.as_deref(), target.as_deref())?;
+            }
         }
     }
     clean_project_at(root, flags.profile.as_deref(), target.as_deref())
 }
 
+/// Removes build artifacts for a single project directory.
+///
+/// When `profile` is set, only that profile's directory under `target` (optionally
+/// scoped by `target` triple) is removed, plus custom paths for that profile.
+/// When `profile` is `None`, the entire `target` tree is removed and custom paths
+/// are cleaned for both `debug` and `release`.
 fn clean_project_at(
     project_root: &Path,
     profile: Option<&str>,
@@ -183,6 +222,7 @@ fn clean_project_at(
             };
             let target_items = check_dir(Some("target")).unwrap_or_default();
             let parent_dir = target.unwrap_or("");
+            // Existence check differs: with a triple, look for target/<triple>; otherwise target/<profile>.
             let dir_exists = if target.is_some() {
                 target_items.contains(&parent_dir.to_string())
             } else {
@@ -221,6 +261,10 @@ fn clean_project_at(
     })
 }
 
+/// Deletes extra paths listed under `build.clean` in `dcr.toml` for a profile.
+///
+/// Each pattern may contain `{profile}` and version placeholders, which are
+/// expanded before matching with `glob`. Matched files and directories are removed.
 fn clean_custom_paths(config: &Config, profile: &str) -> Result<(), String> {
     let patterns = match config.get("build.clean") {
         Some(v) => v
@@ -230,7 +274,7 @@ fn clean_custom_paths(config: &Config, profile: &str) -> Result<(), String> {
             .filter_map(|item| item.as_str())
             .map(|s| {
                 let value = s.replace("{profile}", profile);
-                substitute_version_vars(&value, config)
+                substitute_clean_vars(&value, config)
             })
             .collect::<Vec<String>>(),
         None => Vec::new(),
@@ -251,17 +295,15 @@ fn clean_custom_paths(config: &Config, profile: &str) -> Result<(), String> {
     Ok(())
 }
 
-fn substitute_version_vars(value: &str, config: &Config) -> String {
+/// Expands version-related placeholders in a clean path pattern.
+///
+/// Reads `package.version` from `config`, parses it, and applies
+/// [`crate::utils::build::substitute_version_vars`].
+fn substitute_clean_vars(value: &str, config: &Config) -> String {
     let version = config
         .get("package.version")
         .and_then(|v| v.as_str())
         .unwrap_or("");
     let info = parse_version_info(version);
-    value
+    crate::utils::build::substitute_version_vars(value, &info)
-        .replace("{version}", &info.full)
-        .replace("{version_major}", &info.major)
-        .replace("{version_minor}", &info.minor)
-        .replace("{version_patch}", &info.patch)
-        .replace("{version_suffix}", &info.suffix)
-        .replace("{version_suffix_dash}", &info.suffix_dash)
 }

src/cli/flag_update.rs

@@ -16,9 +16,10 @@
 // along with this program.  If not, see <https://www.gnu.org/licenses/>.
 
 use crate::utils::log::{error, warn};
-use reqwest::blocking::Client;
+use crate::utils::text::{BOLD_CYAN, BOLD_GREEN, printc};
 use serde::Deserialize;
 use std::fs;
+use std::io::Read;
 use std::path::{Path, PathBuf};
 #[cfg(target_os = "linux")]
 use std::process::Command;
@@ -26,19 +27,42 @@ use std::time::{SystemTime, UNIX_EPOCH};
 
 const LATEST_RELEASE_URL: &str = "https://api.github.com/repos/dexoron/dcr/releases/latest";
 
+/// Metadata for the latest GitHub release of DCR.
 #[derive(Debug, Deserialize)]
 struct Release {
+    /// Release tag, typically including a leading `v` (e.g. `v1.2.3`).
     tag_name: String,
+    /// Downloadable assets attached to the release.
     assets: Vec<ReleaseAsset>,
 }
 
+/// A single downloadable asset from a GitHub release.
 #[derive(Debug, Deserialize)]
 struct ReleaseAsset {
+    /// Asset file name as published on GitHub.
     name: String,
+    /// Direct URL used to download the asset.
     browser_download_url: String,
 }
 
+/// Handles the `dcr --update` flag: checks GitHub for a newer release and
+/// replaces the running binary when an update is available.
+///
+/// # Parameters
+/// - `args`: Remaining tokens after `--update` (only `--help` is accepted).
+///
+/// # Returns
+/// `0` on success / already up to date / pacman-managed refuse; `1` on error.
 pub fn flag_update(args: &[String]) -> i32 {
+    if args.first().is_some_and(|a| a == "--help") {
+        printc("USAGE:", BOLD_GREEN);
+        printc("    dcr --update", BOLD_CYAN);
+        println!();
+        printc("DESCRIPTION:", BOLD_GREEN);
+        println!("    Updates DCR to the latest version from GitHub Releases.");
+        return 0;
+    }
+
     if !args.is_empty() {
         warn("Command does not support additional arguments");
         return 1;
@@ -52,6 +76,7 @@ pub fn flag_update(args: &[String]) -> i32 {
         }
     };
 
+    // Refuse self-update when the binary is owned by pacman/AUR.
     if let Some(package_name) = pacman_owned_package(&current_exe) {
         warn("This dcr binary is managed by pacman/AUR");
         println!(
@@ -62,15 +87,8 @@ pub fn flag_update(args: &[String]) -> i32 {
 
     let current_version = env!("CARGO_PKG_VERSION");
     let target = env!("DCR_TARGET");
-    let client = match Client::builder().user_agent("dcr-updater").build() {
-        Ok(client) => client,
-        Err(_) => {
-            error("Failed to initialize HTTP client");
-            return 1;
-        }
-    };
 
-    let release = match fetch_latest_release(&client) {
+    let release = match fetch_latest_release() {
         Ok(release) => release,
         Err(err) => {
             error(&format!("Failed to check for updates: {err}"));
@@ -78,6 +96,7 @@ pub fn flag_update(args: &[String]) -> i32 {
         }
     };
 
+    // Normalize the tag by stripping a leading `v` before comparison.
     let latest_version = release.tag_name.trim_start_matches('v');
     if latest_version == current_version {
         println!("Latest version is already installed: {current_version}");
@@ -94,7 +113,7 @@ pub fn flag_update(args: &[String]) -> i32 {
         return 1;
     };
 
-    let bytes = match download_asset(&client, &asset.browser_download_url) {
+    let bytes = match download_asset(&asset.browser_download_url) {
         Ok(bytes) => bytes,
         Err(err) => {
             error(&format!("Failed to download update: {err}"));
@@ -110,6 +129,7 @@ pub fn flag_update(args: &[String]) -> i32 {
     }
     set_executable_permissions(&temp_path);
 
+    // Replace the running executable in place, then clean up the temp file.
     if self_replace::self_replace(&temp_path).is_err() {
         let _ = fs::remove_file(&temp_path);
         error("Failed to replace current binary");
@@ -121,40 +141,44 @@ pub fn flag_update(args: &[String]) -> i32 {
     0
 }
 
-fn fetch_latest_release(client: &Client) -> Result<Release, String> {
+/// Fetches the latest DCR release metadata from the GitHub Releases API.
-    let response = client
+fn fetch_latest_release() -> Result<Release, String> {
-        .get(LATEST_RELEASE_URL)
+    let response = ureq::get(LATEST_RELEASE_URL)
-        .send()
+        .set("User-Agent", "dcr-updater")
-        .map_err(|_| "GitHub API request failed".to_string())?;
+        .call()
-
+        .map_err(|e| match e {
-    if !response.status().is_success() {
+            ureq::Error::Status(code, _) => format!("GitHub API returned status {code}"),
-        return Err(format!("GitHub API returned status {}", response.status()));
+            ureq::Error::Transport(e) => format!("GitHub API request failed: {e}"),
-    }
+        })?;
 
     response
-        .json::<Release>()
+        .into_json::<Release>()
         .map_err(|_| "GitHub API response has an unexpected format".to_string())
 }
 
-fn download_asset(client: &Client, url: &str) -> Result<Vec<u8>, String> {
+/// Downloads a release asset from the given URL into memory.
-    let response = client
+fn download_asset(url: &str) -> Result<Vec<u8>, String> {
-        .get(url)
+    let response = ureq::get(url)
-        .send()
+        .set("User-Agent", "dcr-updater")
-        .map_err(|_| "Download request failed".to_string())?;
+        .call()
+        .map_err(|e| match e {
+            ureq::Error::Status(code, _) => format!("Download returned status {code}"),
+            ureq::Error::Transport(e) => format!("Download request failed: {e}"),
+        })?;
 
-    if !response.status().is_success() {
+    let mut reader = response.into_reader();
-        return Err(format!("Download returned status {}", response.status()));
+    let mut data = Vec::new();
-    }
+    reader
-
+        .read_to_end(&mut data)
-    response
+        .map_err(|_| "Failed to read downloaded data".to_string())?;
-        .bytes()
+    Ok(data)
-        .map(|bytes| bytes.to_vec())
-        .map_err(|_| "Failed to read downloaded data".to_string())
 }
 
+/// Builds the list of expected asset file names for the given build target.
 fn asset_candidates(target: &str) -> Vec<String> {
     let mut names = vec![format!("dcr-{target}")];
 
+    // Windows releases may publish the binary with an `.exe` suffix.
     if target.contains("-windows-") || target.ends_with("-windows") {
         names.push(format!("dcr-{target}.exe"));
     }
@@ -162,6 +186,7 @@ fn asset_candidates(target: &str) -> Vec<String> {
     names
 }
 
+/// Creates a unique temporary path next to the current executable for the download.
 fn temp_binary_path(current_exe: &Path) -> PathBuf {
     let stamp = SystemTime::now()
         .duration_since(UNIX_EPOCH)
@@ -174,6 +199,7 @@ fn temp_binary_path(current_exe: &Path) -> PathBuf {
     current_exe.with_extension(extension)
 }
 
+/// Sets executable permissions on Unix; no-op on other platforms.
 fn set_executable_permissions(_path: &Path) {
     #[cfg(unix)]
     {
@@ -186,6 +212,7 @@ fn set_executable_permissions(_path: &Path) {
     }
 }
 
+/// On Linux, returns the pacman package that owns `path`, if any.
 #[cfg(target_os = "linux")]
 fn pacman_owned_package(path: &Path) -> Option<String> {
     let output = Command::new("pacman").arg("-Qoq").arg(path).output().ok()?;
@@ -201,6 +228,7 @@ fn pacman_owned_package(path: &Path) -> Option<String> {
     Some(package_name)
 }
 
+/// Non-Linux stub: package-manager ownership is not checked.
 #[cfg(not(target_os = "linux"))]
 fn pacman_owned_package(_path: &Path) -> Option<String> {
     None

src/cli/flags.rs

@@ -18,25 +18,69 @@
 use crate::config::{PROFILE, flags};
 use crate::utils::log::warn;
 
+/// Flags shared by the `build` and `run` CLI commands.
 pub struct BuildRunFlags {
+    /// Build profile name (for example `debug` or `release`).
     pub profile: String,
+    /// Optional target triple or platform name.
     pub target: Option<String>,
+    /// Optional workspace member name (`--workspace <name>`).
     pub workspace: Option<String>,
+    /// Force a rebuild even when artifacts appear up to date.
     pub force: bool,
+    /// Clean build outputs before building.
     pub clean: bool,
+    /// Enable verbose logging during the build or run.
     pub verbose: bool,
+    /// Print the final artifact path to the user.
+    pub print_artifact_path: bool,
+    /// Arguments forwarded to the binary after a `--` separator.
+    pub bin_args: Vec<String>,
 }
 
+/// Splits CLI arguments at the first `--` separator.
+///
+/// Everything before `--` is treated as DCR flags; everything after is
+/// forwarded to the built binary as `bin_args`.
+///
+/// # Parameters
+/// - `args`: Full argument list for the command (without the program name).
+///
+/// # Returns
+/// `(dcr_args, bin_args)`. If `--` is absent, `bin_args` is empty.
+pub fn split_double_dash(args: &[String]) -> (&[String], &[String]) {
+    match args.iter().position(|a| a == "--") {
+        Some(i) => (&args[..i], &args[i + 1..]),
+        None => (args, &[]),
+    }
+}
+
+/// Parses build/run flags from a list of CLI arguments.
+///
+/// Recognizes boolean flags (`--force`, `--clean`, `--verbose`,
+/// `--print-artifact-path`), value flags (`--workspace`, `--target`), and
+/// profile names registered via [`flags`]. Arguments after `--` become
+/// [`BuildRunFlags::bin_args`].
+///
+/// # Parameters
+/// - `args`: CLI arguments for build/run (may include `--`).
+///
+/// # Returns
+/// - `Ok(BuildRunFlags)` on success.
+/// - `Err(1)` for unknown flags, missing values, or a duplicate profile.
 pub fn parse_build_run_flags(args: &[String]) -> Result<BuildRunFlags, i32> {
+    let (dcr_args, bin_args_slice) = split_double_dash(args);
     let mut profile = PROFILE.to_string();
     let mut target = None;
     let mut workspace = None;
     let mut force = false;
     let mut clean = false;
     let mut verbose = false;
-    let mut iter = args.iter();
+    let mut print_artifact_path = false;
+    let mut iter = dcr_args.iter();
 
     while let Some(arg) = iter.next() {
+        // DCR build/run options are long flags only (`--name`).
         if !arg.starts_with("--") {
             warn("Unknown argument");
             return Err(1);
@@ -54,6 +98,10 @@ pub fn parse_build_run_flags(args: &[String]) -> Result<BuildRunFlags, i32> {
             verbose = true;
             continue;
         }
+        if candidate == "print-artifact-path" {
+            print_artifact_path = true;
+            continue;
+        }
         if candidate == "workspace" {
             if let Some(w) = iter.next() {
                 workspace = Some(w.clone());
@@ -72,6 +120,7 @@ pub fn parse_build_run_flags(args: &[String]) -> Result<BuildRunFlags, i32> {
             }
             continue;
         }
+        // Profile names come from config::flags; only one profile may be set.
         if flags(candidate).is_some() {
             if profile != PROFILE {
                 warn("Duplicate profile flag");
@@ -91,5 +140,43 @@ pub fn parse_build_run_flags(args: &[String]) -> Result<BuildRunFlags, i32> {
         force,
         clean,
         verbose,
+        print_artifact_path,
+        bin_args: bin_args_slice.to_vec(),
     })
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    /// Converts string literals into owned `String` CLI arguments for tests.
+    fn s(args: &[&str]) -> Vec<String> {
+        args.iter().map(|a| a.to_string()).collect()
+    }
+
+    /// Checks that without `--`, the full list stays on the DCR side.
+    #[test]
+    fn split_double_dash_empty_tail() {
+        let args = s(&["--release", "--force"]);
+        let (left, right) = split_double_dash(&args);
+        assert_eq!(left, &s(&["--release", "--force"]));
+        assert!(right.is_empty());
+    }
+
+    /// Checks that arguments after `--` are split into the bin-args slice.
+    #[test]
+    fn split_double_dash_with_bin_args() {
+        let args = s(&["--release", "--", "--test_help", "x"]);
+        let (left, right) = split_double_dash(&args);
+        assert_eq!(left, &s(&["--release"]));
+        assert_eq!(right, &s(&["--test_help", "x"]));
+    }
+
+    /// Checks profile parsing and that bin args after `--` are forwarded.
+    #[test]
+    fn parse_run_flags_forwards_after_double_dash() {
+        let flags = parse_build_run_flags(&s(&["--release", "--", "--test_help"])).unwrap();
+        assert_eq!(flags.profile, "release");
+        assert_eq!(flags.bin_args, s(&["--test_help"]));
+    }
+}

src/cli/fmt.rs

@@ -16,11 +16,28 @@
 // along with this program.  If not, see <https://www.gnu.org/licenses/>.
 
 use crate::utils::log::error;
-use crate::utils::text::{BOLD_GREEN, colored};
+use crate::utils::text::{BOLD_CYAN, BOLD_GREEN, colored, printc};
 use glob::glob;
 use std::process::Command;
 
-pub fn fmt(_args: &[String]) -> i32 {
+/// Formats all C/C++ source files using clang-format.
+///
+/// Scans the `src/` and `tests/` directories recursively for files with common
+/// C/C++ extensions and formats them in place with clang-format.
+///
+/// If the first argument is `--help`, prints usage information and returns 0.
+pub fn fmt(args: &[String]) -> i32 {
+    if args.first().is_some_and(|a| a == "--help") {
+        printc("USAGE:", BOLD_GREEN);
+        printc("    dcr fmt", BOLD_CYAN);
+        println!();
+        printc("DESCRIPTION:", BOLD_GREEN);
+        println!("    Formats all C/C++ source files using clang-format.");
+        println!("    Scans src/ and tests/ directories recursively.");
+        return 0;
+    }
+
+    // Collect all matching files from src/ and tests/ using glob patterns
     let patterns = [
         "src/**/*.c",
         "src/**/*.cpp",
@@ -56,6 +73,7 @@ pub fn fmt(_args: &[String]) -> i32 {
         return 0;
     }
 
+    // Format the collected files
     println!(
         "    {} {} files",
         colored("Formatting", BOLD_GREEN),

src/cli/help.rs

@@ -17,6 +17,12 @@
 
 use crate::utils::text::{BOLD_CYAN, BOLD_GREEN, printc};
 
+/// Displays the help information for the DCR CLI tool.
+///
+/// Prints usage, commands, flags, options, examples, and a tip.
+///
+/// # Returns
+/// Always `0`.
 pub fn help() -> i32 {
     println!("DCR (Dexoron Cargo Realization)");
     println!("C project manager inspired by Cargo.");
@@ -29,9 +35,12 @@ pub fn help() -> i32 {
     println!("    init              Initialize the current directory as a project");
     println!("    build [--profile] Build the project (default: --debug)");
     println!("    run [--profile]   Build and run the project (default: --debug)");
+    println!("    add <name> ...    Add a dependency to dcr.toml");
     println!("    tree              Display the dependency tree");
     println!("    test              Run project tests (alias: tests)");
     println!("    fmt               Format all C/C++ source files using clang-format");
+    println!("    lint              Run clang-tidy on C/C++ sources");
+    println!("    setup             Show configured package registries");
     println!("    clean             Remove the target directory");
     println!("    gen <subcommand>  Generate IDE integration files");
     printc("FLAGS:", BOLD_GREEN);

src/cli/init.rs

@@ -16,7 +16,8 @@
 // along with this program.  If not, see <https://www.gnu.org/licenses/>.
 
 use crate::config::FILE_MAIN_C;
-use crate::core::config::Config;
+use crate::core::build_config::{Config, validate_package_name};
+use crate::core::vcs::VcsKind;
 use crate::utils::fs::check_dir;
 use crate::utils::log::{error, warn};
 use crate::utils::text::{BOLD_CYAN, BOLD_GREEN, colored, printc};
@@ -24,12 +25,46 @@ use std::fs;
 use std::io::Write;
 use toml::Value;
 
+/// Initializes the current working directory as a new DCR project.
+///
+/// Verifies that the current directory is empty, sets up the project structure by creating
+/// `dcr.toml` and `src/main.c`, and configures version control (Git) integration if applicable.
 pub fn init(args: &[String]) -> i32 {
-    if !args.is_empty() {
+    if args.first().is_some_and(|a| a == "--help") {
+        printc("USAGE:", BOLD_GREEN);
+        printc("    dcr init [--vcs <git|none>]", BOLD_CYAN);
+        println!();
+        printc("DESCRIPTION:", BOLD_GREEN);
+        println!("    Initializes the current directory as a DCR project.");
+        println!("    The directory must be empty.");
+        return 0;
+    }
+
+    // Parse options (--vcs) and collect positional arguments.
+    let mut vcs_str = None;
+    let mut clean_args = Vec::new();
+    let mut iter = args.iter();
+    while let Some(arg) = iter.next() {
+        if arg == "--vcs" {
+            if let Some(val) = iter.next() {
+                vcs_str = Some(val.clone());
+            } else {
+                error("--vcs requires a value");
+                return 1;
+            }
+        } else if let Some(stripped) = arg.strip_prefix("--vcs=") {
+            vcs_str = Some(stripped.to_string());
+        } else {
+            clean_args.push(arg.clone());
+        }
+    }
+
+    if !clean_args.is_empty() {
         warn("Command does not support additional arguments");
         return 1;
     }
 
+    // Resolve target project name from current directory name and enforce empty directory check.
     let items = check_dir(None).unwrap_or_default();
     let project_name = std::env::current_dir()
         .ok()
@@ -41,11 +76,21 @@ pub fn init(args: &[String]) -> i32 {
         return 1;
     }
 
+    if let Err(e) = validate_package_name(&project_name) {
+        error(&format!(
+            "Invalid project name `{}`: {}",
+            colored(&project_name, BOLD_CYAN),
+            e
+        ));
+        return 1;
+    }
+
     let cwd = std::env::current_dir()
         .map(|v| v.to_string_lossy().to_string())
         .unwrap_or_else(|_| ".".to_string());
     println!("Initializing the project in {cwd}");
 
+    // Create and initialize default manifest (dcr.toml).
     let mut config = match Config::new("./dcr.toml") {
         Ok(cfg) => cfg,
         Err(_) => {
@@ -66,6 +111,7 @@ pub fn init(args: &[String]) -> i32 {
         colored("dcr.toml", BOLD_CYAN)
     );
 
+    // Create src directory and write template main.c file.
     if fs::create_dir("src").is_err() {
         error("Failed to create src/");
         return 1;
@@ -87,6 +133,44 @@ pub fn init(args: &[String]) -> i32 {
         colored("src/main.c", BOLD_CYAN)
     );
 
+    // Resolve target VCS provider or detect existing repositories.
+    let mut vcs_kind = VcsKind::Git;
+    if let Some(ref vcs_val) = vcs_str {
+        match VcsKind::parse(vcs_val) {
+            Ok(kind) => vcs_kind = kind,
+            Err(e) => {
+                error(&e);
+                return 1;
+            }
+        }
+    } else if let Ok(cwd_path) = std::env::current_dir()
+        && crate::core::vcs::find_existing_vcs(&cwd_path).is_some()
+    {
+        vcs_kind = VcsKind::None;
+    }
+
+    if vcs_kind == VcsKind::Git {
+        if crate::utils::git::is_git_available() {
+            let project_path = std::path::Path::new(".");
+            if let Err(e) = crate::core::vcs::init_vcs(vcs_kind, project_path) {
+                warn(&format!("Failed to initialize git repository: {}", e));
+            } else {
+                println!(
+                    "    {} Initialized git repository",
+                    colored("✔", BOLD_GREEN)
+                );
+            }
+        } else {
+            warn(
+                "Git is not installed or not found in PATH. Skipping Git repository initialization.",
+            );
+        }
+    }
+
+    if let Err(e) = crate::utils::fs::ensure_gitignore_has_dcr(std::path::Path::new(".")) {
+        warn(&format!("Failed to update .gitignore: {e}"));
+    }
+
     println!(
         "Project `{}` successfully created\n",
         colored(project_name.as_str(), BOLD_GREEN)

src/cli/lint.rs

@@ -0,0 +1,194 @@
+// DCR — Cargo-like C/C++ project manager.
+//
+// Copyright (C) 2026 Dexoron (Bezotechestvo Vladimir) <main@dexoron.su>
+//
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with this program.  If not, see <https://www.gnu.org/licenses/>.
+
+use crate::core::build::common;
+use crate::core::build_config::Config;
+use crate::utils::build::{get_bool_with_profile, get_list_with_profile};
+use crate::utils::fs::find_project_root;
+use crate::utils::log::error;
+use crate::utils::text::{BOLD_CYAN, BOLD_GREEN, BOLD_YELLOW, colored, printc};
+use std::path::{Path, PathBuf};
+use std::process::Command;
+
+/// Runs clang-tidy on all C/C++ source files.
+///
+/// Scans source roots (configurable via build.roots) and tests/ directory.
+pub fn lint(args: &[String]) -> i32 {
+    if args.first().is_some_and(|a| a == "--help") {
+        printc("USAGE:", BOLD_GREEN);
+        printc("    dcr lint [--fix]", BOLD_CYAN);
+        println!();
+        printc("DESCRIPTION:", BOLD_GREEN);
+        println!("    Runs clang-tidy on all C/C++ source files.");
+        println!("    Scans source roots (configurable via build.roots) and tests/ directory.");
+        println!();
+        printc("OPTIONS:", BOLD_GREEN);
+        println!("    --fix    Apply clang-tidy suggestions automatically");
+        return 0;
+    }
+
+    let do_fix = args.iter().any(|a| a == "--fix");
+
+    let start_dir = match std::env::current_dir() {
+        Ok(dir) => dir,
+        Err(_) => {
+            error("Failed to determine current directory");
+            return 1;
+        }
+    };
+
+    let root = match find_project_root(&start_dir) {
+        Ok(Some(r)) => r,
+        Ok(None) => {
+            error("dcr.toml not found");
+            return 1;
+        }
+        Err(_) => {
+            error("Failed to find project root");
+            return 1;
+        }
+    };
+
+    let config = match Config::open(&root.join("dcr.toml").to_string_lossy()) {
+        Ok(c) => c,
+        Err(e) => {
+            error(&format!("Failed to load dcr.toml: {e}"));
+            return 1;
+        }
+    };
+
+    let profile = "debug";
+    let build_roots = get_list_with_profile(&config, "roots", profile);
+    let src_disable = get_bool_with_profile(&config, "src_disable", profile, false);
+
+    // Construct source roots from config
+    let mut source_roots: Vec<String> = Vec::new();
+    for raw in &build_roots {
+        let p = Path::new(raw);
+        if p.is_absolute() {
+            source_roots.push(raw.clone());
+        } else {
+            source_roots.push(root.join(p).to_string_lossy().to_string());
+        }
+    }
+    if !src_disable && source_roots.is_empty() {
+        source_roots.push(root.join("src").to_string_lossy().to_string());
+    }
+
+    let cxx_extensions = ["c", "cpp", "cxx", "cc"];
+    let exclude_dirs: Vec<PathBuf> = Vec::new();
+    let include_paths: Vec<String> = Vec::new();
+
+    let roots: Vec<PathBuf> = source_roots.iter().map(PathBuf::from).collect();
+    let mut files =
+        match common::collect_sources(&roots, &cxx_extensions, &exclude_dirs, &include_paths) {
+            Ok(f) => f,
+            Err(e) => {
+                error(&format!("Failed to collect source files: {e}"));
+                return 1;
+            }
+        };
+
+    let tests_dir = root.join("tests");
+    if tests_dir.is_dir() {
+        let test_roots = vec![tests_dir];
+        if let Ok(mut test_files) =
+            common::collect_sources(&test_roots, &cxx_extensions, &exclude_dirs, &include_paths)
+        {
+            files.append(&mut test_files);
+        }
+    }
+
+    files.sort();
+
+    if files.is_empty() {
+        println!("    {} No files to lint", colored("Lint", BOLD_GREEN));
+        return 0;
+    }
+
+    println!(
+        "    {} {} files {}",
+        colored("Linting", BOLD_GREEN),
+        files.len(),
+        if do_fix { "(with --fix)" } else { "" }
+    );
+
+    let mut total_issues = 0u32;
+    let mut failed = 0u32;
+
+    // Execute clang-tidy for each file and count issues
+    for file in &files {
+        let mut cmd = Command::new("clang-tidy");
+        if do_fix {
+            cmd.arg("--fix");
+        }
+        cmd.arg("--quiet");
+        cmd.arg(file);
+
+        let output = match cmd.output() {
+            Ok(o) => o,
+            Err(e) => {
+                error(&format!("Failed to execute clang-tidy: {}", e));
+                return 1;
+            }
+        };
+
+        let stderr = String::from_utf8_lossy(&output.stderr);
+        let stdout = String::from_utf8_lossy(&output.stdout);
+        let combined = format!("{}{}", stdout, stderr);
+
+        let issues: Vec<&str> = combined
+            .lines()
+            .filter(|l| l.contains("warning:") || l.contains("error:"))
+            .collect();
+        let issue_count = issues.len();
+
+        if issue_count > 0 {
+            total_issues += issue_count as u32;
+            failed += 1;
+            print!("  {} ", colored("×", BOLD_YELLOW));
+            println!("{} ({} issues)", file, issue_count);
+            for issue in &issues {
+                println!("    {}", issue);
+            }
+        } else {
+            print!("  {} ", colored("✓", BOLD_GREEN));
+            println!("{}", file);
+        }
+    }
+
+    let total = files.len();
+    let passed = total - failed as usize;
+
+    if failed == 0 {
+        println!(
+            "    {} {} files, no issues",
+            colored("Lint", BOLD_GREEN),
+            total
+        );
+    } else {
+        println!(
+            "    {} {}/{} files passed, {} issues found",
+            colored("Lint", BOLD_YELLOW),
+            passed,
+            total,
+            total_issues
+        );
+    }
+
+    0
+}

src/cli/mod.rs

@@ -15,6 +15,9 @@
 // You should have received a copy of the GNU General Public License
 // along with this program.  If not, see <https://www.gnu.org/licenses/>.
 
+/// DCR CLI module.
+///
+/// This module declares submodules for all DCR commands.
 pub mod add;
 pub mod build;
 pub mod clean;
@@ -24,6 +27,7 @@ pub mod fmt;
 pub mod r#gen;
 pub mod help;
 pub mod init;
+pub mod lint;
 pub mod new;
 pub mod run;
 pub mod setup;

src/cli/new.rs

@@ -16,7 +16,8 @@
 // along with this program.  If not, see <https://www.gnu.org/licenses/>.
 
 use crate::config::FILE_MAIN_C;
-use crate::core::config::Config;
+use crate::core::build_config::{Config, validate_package_name};
+use crate::core::vcs::VcsKind;
 use crate::utils::fs::check_dir;
 use crate::utils::log::{error, warn};
 use crate::utils::text::{BOLD_CYAN, BOLD_GREEN, colored, printc};
@@ -24,30 +25,72 @@ use std::fs;
 use std::io::Write;
 use toml::Value;
 
+/// Executes the `dcr new` command to scaffold a new C/C++ project directory structure.
+///
+/// Handles command-line argument parsing, directory creation, default configuration generation (`dcr.toml`),
+/// template source file generation (`src/main.c`), and initial VCS setup.
 pub fn new(args: &[String]) -> i32 {
+    if args.first().is_some_and(|a| a == "--help") {
+        printc("USAGE:", BOLD_GREEN);
+        printc("    dcr new <name> [--vcs <git|none>]", BOLD_CYAN);
+        println!();
+        printc("DESCRIPTION:", BOLD_GREEN);
+        println!("    Creates a new C/C++ project with the given name.");
+        println!("    The name may only contain ASCII letters, digits, '_' and '-'.");
+        return 0;
+    }
+
     let items = check_dir(None).unwrap_or_default();
 
-    if args.is_empty() {
+    // Parse CLI options (--vcs) while extracting positional arguments for the project name.
+    let mut vcs_str = None;
+    let mut clean_args = Vec::new();
+    let mut iter = args.iter();
+    while let Some(arg) = iter.next() {
+        if arg == "--vcs" {
+            if let Some(val) = iter.next() {
+                vcs_str = Some(val.clone());
+            } else {
+                error("--vcs requires a value");
+                return 1;
+            }
+        } else if let Some(stripped) = arg.strip_prefix("--vcs=") {
+            vcs_str = Some(stripped.to_string());
+        } else {
+            clean_args.push(arg.clone());
+        }
+    }
+
+    if clean_args.is_empty() {
         error("Project name not specified");
         return 1;
     }
-    if args.len() > 1 {
+    if clean_args.len() > 1 {
         warn("Command does not support additional arguments");
         return 1;
     }
 
-    let project_name = &args[0];
+    let project_name = &clean_args[0];
     println!(
         "Creating a Project `{}`...",
         colored(project_name, BOLD_CYAN)
     );
 
+    if let Err(e) = validate_package_name(project_name) {
+        error(&format!(
+            "Invalid project name `{}`: {}",
+            colored(project_name, BOLD_CYAN),
+            e
+        ));
+        return 1;
+    }
+
     if items.contains(project_name) {
         error(&format!(
             "Directory `{}` already exists\n",
             colored(project_name, BOLD_CYAN)
         ));
-        printc("Подсказка:", BOLD_CYAN);
+        printc("Hint:", BOLD_CYAN);
         println!(
             "    Use `{}` to initialize an existing project\n    or specify a different project name",
             colored("dcr init", BOLD_CYAN)
@@ -65,6 +108,7 @@ pub fn new(args: &[String]) -> i32 {
         project_name
     );
 
+    // Initialize and write project configuration manifest (dcr.toml).
     let toml_path = format!("./{project_name}/dcr.toml");
     let mut config = match Config::new(&toml_path) {
         Ok(cfg) => cfg,
@@ -86,6 +130,7 @@ pub fn new(args: &[String]) -> i32 {
         colored("dcr.toml", BOLD_CYAN)
     );
 
+    // Generate src directory and populate initial main.c file.
     if fs::create_dir_all(format!("./{project_name}/src")).is_err() {
         error("Failed to create src/");
         return 1;
@@ -108,6 +153,45 @@ pub fn new(args: &[String]) -> i32 {
         colored("src/main.c", BOLD_CYAN)
     );
 
+    // Resolve target VCS mode based on CLI flags or parent directory state.
+    let mut vcs_kind = VcsKind::Git;
+    if let Some(ref vcs_val) = vcs_str {
+        match VcsKind::parse(vcs_val) {
+            Ok(kind) => vcs_kind = kind,
+            Err(e) => {
+                error(&e);
+                return 1;
+            }
+        }
+    } else if let Ok(cwd) = std::env::current_dir()
+        && crate::core::vcs::find_existing_vcs(&cwd).is_some()
+    {
+        vcs_kind = VcsKind::None;
+    }
+
+    if vcs_kind == VcsKind::Git {
+        if crate::utils::git::is_git_available() {
+            let project_path = std::path::Path::new(project_name);
+            if let Err(e) = crate::core::vcs::init_vcs(vcs_kind, project_path) {
+                warn(&format!("Failed to initialize git repository: {}", e));
+            } else {
+                println!(
+                    "    {} Initialized git repository",
+                    colored("✔", BOLD_GREEN)
+                );
+            }
+        } else {
+            warn(
+                "Git is not installed or not found in PATH. Skipping Git repository initialization.",
+            );
+        }
+    }
+
+    let project_path = std::path::Path::new(project_name);
+    if let Err(e) = crate::utils::fs::ensure_gitignore_has_dcr(project_path) {
+        warn(&format!("Failed to update .gitignore: {e}"));
+    }
+
     println!(
         "Project `{}` successfully created\n",
         colored(project_name, BOLD_GREEN)

src/cli/run.rs

@@ -17,16 +17,18 @@
 
 use crate::cli::build::build;
 use crate::cli::flags::parse_build_run_flags;
-use crate::core::config::Config;
+use crate::core::build_config::Config;
 use crate::core::runner::run_binary;
-use crate::utils::build::{normalize_target_os, parse_version_info};
+use crate::utils::build::{normalize_target_os, parse_version_info, substitute_vars};
 use crate::utils::fs::find_project_root;
 use crate::utils::fs::with_dir;
 use crate::utils::log::error;
-use crate::utils::text::{BOLD_GREEN, colored};
+use crate::utils::text::{BOLD_CYAN, BOLD_GREEN, colored, printc};
 use std::path::Path;
 use std::process::Command;
 
+/// Retrieves the run command from the config, preferring target-specific,
+/// then profile-specific, then the base `run.cmd`.
 fn get_run_cmd(
     config: &Config,
     profile: &str,
@@ -55,7 +57,37 @@ fn get_run_cmd(
     }
 }
 
+/// Handles the `dcr run` subcommand: parses flags, finds the project root,
+/// builds if needed, and runs the resulting binary or configured command.
+///
+/// # Parameters
+/// - `args`: Tokens after `dcr run` (build flags; after `--` → binary args).
+///
+/// # Returns
+/// Process exit code from the built binary / `run.cmd`, or non-zero on build/setup failure.
 pub fn run(args: &[String]) -> i32 {
+    if args.first().is_some_and(|a| a == "--help") {
+        printc("USAGE:", BOLD_GREEN);
+        printc(
+            "    dcr run [--debug | --release] [--target <triple>] [--force] [--clean] [--verbose] [-- <args>...]",
+            BOLD_CYAN,
+        );
+        println!();
+        printc("DESCRIPTION:", BOLD_GREEN);
+        println!("    Builds and runs the project. Only available for kind = \"bin\".");
+        println!("    Arguments after `--` are passed to the built binary (cargo-style).");
+        println!();
+        printc("OPTIONS:", BOLD_GREEN);
+        println!("    --debug              Run with debug profile (default)");
+        println!("    --release            Run with release profile");
+        println!("    --target <triple>    Cross-compile for the given target");
+        println!("    --force              Force a full rebuild");
+        println!("    --clean              Clean before building");
+        println!("    --verbose            Print detailed build output");
+        println!("    -- <args>...         Arguments forwarded to the binary");
+        return 0;
+    }
+
     let start_dir = match std::env::current_dir() {
         Ok(dir) => dir,
         Err(_) => {
@@ -88,8 +120,21 @@ pub fn run(args: &[String]) -> i32 {
         Err(_) => return 1,
     };
 
-    // Handle workspace-only root: delegate to workspace member
     if config.is_workspace_only() {
+        if let Some(cmd) = get_run_cmd(&config, &flags.profile, flags.target.as_deref(), "") {
+            let build_status = build(&args_for_build(&flags));
+            if build_status == 0 {
+                let display = display_run_cmd(&cmd, &flags.bin_args);
+                println!(
+                    "  {} {}",
+                    colored(&format!("{:<9}", "run"), BOLD_GREEN),
+                    display
+                );
+                return run_shell_with_args(&cmd, &flags.bin_args);
+            }
+            return build_status;
+        }
+
         let ws = match crate::core::workspace::parse_workspace(
             &config,
             &flags.profile,
@@ -142,6 +187,7 @@ pub fn run(args: &[String]) -> i32 {
     }
 }
 
+/// Builds and runs a single project at `root` (optionally as a workspace member).
 fn run_project(
     root: &Path,
     flags: &crate::cli::flags::BuildRunFlags,
@@ -155,30 +201,13 @@ fn run_project(
         .and_then(|v| v.as_str())
         .unwrap_or("");
 
-    // If no target specified, use default host target for target-specific config
     let mut target = flags.target.clone();
     if target.is_none() {
-        let default_target = if cfg!(target_os = "linux") {
+        let bt =
-            format!("{}-unknown-linux-gnu", std::env::consts::ARCH)
+            crate::cli::build::get_build_string_with_profile(&config, "target", &flags.profile);
-        } else if cfg!(target_os = "macos") {
+        if !bt.is_empty() {
-            "x86_64-apple-darwin".to_string()
+            target = Some(bt);
-        } else if cfg!(target_os = "windows") {
+        }
-            "x86_64-pc-windows-msvc".to_string()
-        } else if cfg!(any(
-            target_os = "freebsd",
-            target_os = "openbsd",
-            target_os = "netbsd",
-            target_os = "dragonfly"
-        )) {
-            format!(
-                "{}-unknown-{}",
-                std::env::consts::ARCH,
-                std::env::consts::OS
-            )
-        } else {
-            "unknown".to_string()
-        };
-        target = Some(default_target);
     }
 
     let build_kind = config
@@ -189,19 +218,17 @@ fn run_project(
 
     let out_dir =
         crate::cli::build::get_build_string_with_profile(&config, "out_dir", &flags.profile);
-    let normalized_target_dir = if !out_dir.is_empty() {
+    let build_target_str = target.clone().unwrap_or_default();
-        Some(out_dir)
+    let has_explicit = target.as_ref().is_some_and(|t| !t.trim().is_empty());
-    } else {
+
-        match workspace_root {
+    let normalized_target_dir = Some(crate::utils::build::resolve_artifact_target_dir(
-            Some(wr) => target
+        root,
-                .as_ref()
+        workspace_root,
-                .and_then(|t| crate::cli::build::normalize_target(t, &flags.profile))
+        &flags.profile,
-                .map(|rel| wr.join(&rel).to_string_lossy().to_string()),
+        &build_target_str,
-            None => target
+        &out_dir,
-                .as_ref()
+        has_explicit,
-                .and_then(|t| crate::cli::build::normalize_target(t, &flags.profile)),
+    ));
-        }
-    };
 
     let version = config
         .get("package.version")
@@ -211,12 +238,23 @@ fn run_project(
 
     let kind = build_kind.trim();
     if run_cmd.is_none()
-        && (kind == "staticlib" || kind == "sharedlib" || kind == "efi" || kind == "elf")
+        && (kind == "staticlib"
+            || kind == "sharedlib"
+            || kind == "efi"
+            || kind == "elf"
+            || kind == "flat-bin")
     {
         return Err("Cannot run library build".to_string());
     }
 
-    let build_status = build(&args_for_build(flags));
+    let build_status = if let Some(wroot) = workspace_root {
+        with_dir(wroot, || {
+            Ok(build(&args_for_workspace_build(flags, project_name)))
+        })
+        .unwrap_or(1)
+    } else {
+        build(&args_for_build(flags))
+    };
     let bin_path = crate::platform::bin_path(
         &flags.profile,
         project_name,
@@ -224,26 +262,36 @@ fn run_project(
     );
     if build_status == 0 {
         if let Some(cmd) = run_cmd {
-            println!("\n    {} {}", colored("Running", BOLD_GREEN), cmd);
+            let display = display_run_cmd(&cmd, &flags.bin_args);
-            println!("--------------------------------");
+            println!(
-            return Ok(run_shell(&cmd));
+                "  {} {}",
+                colored(&format!("{:<9}", "run"), BOLD_GREEN),
+                display
+            );
+            return Ok(run_shell_with_args(&cmd, &flags.bin_args));
         }
-        println!("\n    {} {}", colored("Running", BOLD_GREEN), bin_path);
+        let display = display_bin_run(&bin_path, &flags.bin_args);
-        println!("--------------------------------");
+        println!(
+            "  {} {}",
+            colored(&format!("{:<9}", "run"), BOLD_GREEN),
+            display
+        );
         return Ok(run_binary(
             project_name,
             &flags.profile,
             normalized_target_dir.as_deref(),
+            &flags.bin_args,
         ));
     }
 
     let fallback_code = if let Some(cmd) = run_cmd {
-        run_shell(&cmd)
+        run_shell_with_args(&cmd, &flags.bin_args)
     } else {
         run_binary(
             project_name,
             &flags.profile,
             normalized_target_dir.as_deref(),
+            &flags.bin_args,
         )
     };
     if fallback_code != 1 {
@@ -253,6 +301,7 @@ fn run_project(
     Err("Fix errors in the code to run the project".to_string())
 }
 
+/// Builds the list of arguments for the build command based on the provided flags.
 fn args_for_build(flags: &crate::cli::flags::BuildRunFlags) -> Vec<String> {
     let mut args = Vec::new();
     args.push(format!("--{}", flags.profile));
@@ -264,12 +313,44 @@ fn args_for_build(flags: &crate::cli::flags::BuildRunFlags) -> Vec<String> {
         args.push("--workspace".to_string());
         args.push(name.clone());
     }
+    if flags.force {
+        args.push("--force".to_string());
+    }
+    if flags.clean {
+        args.push("--clean".to_string());
+    }
     if flags.verbose {
         args.push("--verbose".to_string());
     }
     args
 }
 
+/// Constructs build arguments specifically for a workspace member.
+fn args_for_workspace_build(
+    flags: &crate::cli::flags::BuildRunFlags,
+    member_name: &str,
+) -> Vec<String> {
+    let mut args = Vec::new();
+    args.push(format!("--{}", flags.profile));
+    if let Some(ref target) = flags.target {
+        args.push("--target".to_string());
+        args.push(target.clone());
+    }
+    args.push("--workspace".to_string());
+    args.push(member_name.to_string());
+    if flags.force {
+        args.push("--force".to_string());
+    }
+    if flags.clean {
+        args.push("--clean".to_string());
+    }
+    if flags.verbose {
+        args.push("--verbose".to_string());
+    }
+    args
+}
+
+/// Executes the given shell command and returns its exit code.
 fn run_shell(cmd: &str) -> i32 {
     let status = if cfg!(target_os = "windows") {
         Command::new("cmd").arg("/C").arg(cmd).status()
@@ -283,13 +364,68 @@ fn run_shell(cmd: &str) -> i32 {
     }
 }
 
+/// Runs the command, appending escaped binary arguments if provided.
+fn run_shell_with_args(cmd: &str, bin_args: &[String]) -> i32 {
+    if bin_args.is_empty() {
+        return run_shell(cmd);
+    }
+    let mut full = cmd.to_string();
+    for arg in bin_args {
+        full.push(' ');
+        full.push_str(&shell_escape(arg));
+    }
+    run_shell(&full)
+}
+
+/// Formats the run command string for console output, appending arguments if any.
+fn display_run_cmd(cmd: &str, bin_args: &[String]) -> String {
+    if bin_args.is_empty() {
+        return cmd.to_string();
+    }
+    let mut display = cmd.to_string();
+    for arg in bin_args {
+        display.push(' ');
+        display.push_str(arg);
+    }
+    display
+}
+
+/// Formats the binary path for console display, appending arguments if any.
+fn display_bin_run(bin_path: &str, bin_args: &[String]) -> String {
+    if bin_args.is_empty() {
+        return bin_path.to_string();
+    }
+    let mut display = bin_path.to_string();
+    for arg in bin_args {
+        display.push(' ');
+        display.push_str(arg);
+    }
+    display
+}
+
+/// Escapes the argument for safe shell execution, using double quotes on Windows and single quotes on Unix.
+fn shell_escape(arg: &str) -> String {
+    if cfg!(target_os = "windows") {
+        // cmd.exe: wrap in double quotes and escape embedded quotes.
+        let escaped = arg.replace('"', "\\\"");
+        format!("\"{escaped}\"")
+    } else {
+        // POSIX sh: single-quote and escape embedded single quotes as '\''.
+        let mut out = String::from("'");
+        for ch in arg.chars() {
+            if ch == '\'' {
+                out.push_str("'\\''");
+            } else {
+                out.push(ch);
+            }
+        }
+        out.push('\'');
+        out
+    }
+}
+
+/// Replaces version info and profile in the command template.
 fn substitute_run_vars(cmd: &str, profile: &str, version: &str) -> String {
     let info = parse_version_info(version);
-    cmd.replace("{profile}", profile)
+    substitute_vars(cmd, &info, profile, "")
-        .replace("{version}", &info.full)
-        .replace("{version_major}", &info.major)
-        .replace("{version_minor}", &info.minor)
-        .replace("{version_patch}", &info.patch)
-        .replace("{version_suffix}", &info.suffix)
-        .replace("{version_suffix_dash}", &info.suffix_dash)
 }

src/cli/setup.rs

@@ -15,8 +15,22 @@
 // You should have received a copy of the GNU General Public License
 // along with this program.  If not, see <https://www.gnu.org/licenses/>.
 
-pub fn setup(_args: &[String]) -> i32 {
+use crate::utils::text::{BOLD_CYAN, BOLD_GREEN, printc};
+
+/// Sets up DCR registries by loading the registry manager and printing the list of registries.
+pub fn setup(args: &[String]) -> i32 {
+    if args.first().is_some_and(|a| a == "--help") {
+        printc("USAGE:", BOLD_GREEN);
+        printc("    dcr setup", BOLD_CYAN);
+        println!();
+        printc("DESCRIPTION:", BOLD_GREEN);
+        println!("    Sets up DCR registries. Downloads and indexes");
+        println!("    package registries for dependency resolution.");
+        return 0;
+    }
+
     println!("Setting up DCR registries...");
+    // Load and process the registries, returning 0 on success or 1 on error
     match crate::core::registry::RegistryManager::load() {
         Ok(manager) => {
             println!("Loaded {} registries.", manager.config.registry.len());

src/cli/test.rs

@@ -17,35 +17,36 @@
 
 use crate::cli::build;
 use crate::config::{FILE_DCR_TEST_H, FILE_TEST_C, flags};
-use crate::core::config::Config;
+use crate::core::build_config::Config;
 use crate::utils::build::{
     get_config_opt, get_config_str, get_language_with_profile, get_list_with_profile,
     get_string_with_profile, resolve_compiler, resolve_pkg_config_flags,
 };
 use crate::utils::fs::{find_project_root, with_dir};
 use crate::utils::log::error;
-use crate::utils::text::{BOLD_GREEN, BOLD_RED, RESET, colored};
+use crate::utils::text::{BOLD_CYAN, BOLD_GREEN, BOLD_RED, RESET, colored, printc};
 use std::fs;
 use std::path::{Path, PathBuf};
 use std::process::Command;
 
 const BOLD_BLUE: &str = "\x1b[1m\x1b[94m";
 
+/// Runs project tests and prints a unified testsuite report.
 pub fn test(args: &[String]) -> i32 {
     let mut init_header = false;
     let mut profile = "debug";
     for arg in args {
         if arg == "--help" {
-            println!("USAGE:");
+            printc("USAGE:", BOLD_GREEN);
-            println!("    dcr test [--init] [--debug | --release]");
+            printc("    dcr test [--init] [--debug | --release]", BOLD_CYAN);
             println!();
-            println!("ALIASES:");
+            printc("ALIASES:", BOLD_GREEN);
             println!("    dcr tests");
             println!();
-            println!("DESCRIPTION:");
+            printc("DESCRIPTION:", BOLD_GREEN);
             println!("    Runs project tests and prints a unified testsuite report.");
             println!();
-            println!("OPTIONS:");
+            printc("OPTIONS:", BOLD_GREEN);
             println!("    --init            Create tests/dcr_test.h in current project");
             println!("    --debug           Build and run tests with debug profile (default)");
             println!("    --release         Build and run tests with release profile");
@@ -101,6 +102,7 @@ pub fn test(args: &[String]) -> i32 {
     }
 }
 
+/// Executes the testsuite for the given build profile.
 fn run_testsuite(profile: &str) -> Result<i32, String> {
     if build::build(&[format!("--{profile}")]) != 0 {
         return Ok(1);
@@ -260,6 +262,7 @@ fn run_testsuite(profile: &str) -> Result<i32, String> {
     Ok(0)
 }
 
+/// Collects all .c source files from the tests/ directory.
 fn collect_test_sources() -> Result<Vec<PathBuf>, String> {
     let tests_dir = Path::new("./tests");
     if !tests_dir.is_dir() {
@@ -278,6 +281,7 @@ fn collect_test_sources() -> Result<Vec<PathBuf>, String> {
     Ok(sources)
 }
 
+/// Returns a list of include directories for test compilation.
 fn test_include_dirs(config: &Config, profile: &str) -> Vec<String> {
     let mut dirs = vec![
         "./tests".to_string(),
@@ -288,6 +292,7 @@ fn test_include_dirs(config: &Config, profile: &str) -> Vec<String> {
     dirs
 }
 
+/// Compiles a single test source file to an object file.
 fn compile_test_source(
     compiler: &str,
     standard: &str,
@@ -317,6 +322,7 @@ fn compile_test_source(
     Ok(())
 }
 
+/// Links the test object file into an executable binary.
 fn link_test_binary(
     compiler: &str,
     ldflags: &[String],
@@ -343,6 +349,7 @@ fn link_test_binary(
     Ok(())
 }
 
+/// Prints the stdout and stderr from a command execution.
 fn print_command_output(output: &std::process::Output) {
     if !output.stdout.is_empty() {
         print!("{}", String::from_utf8_lossy(&output.stdout));
@@ -352,6 +359,7 @@ fn print_command_output(output: &std::process::Output) {
     }
 }
 
+/// Creates the default test files (dcr_test.h and test.c) in the tests/ directory.
 fn ensure_test_header() -> Result<(), String> {
     fs::create_dir_all("./tests").map_err(|_| "Failed to create tests/".to_string())?;
     fs::write("./tests/dcr_test.h", FILE_DCR_TEST_H)
@@ -363,6 +371,7 @@ fn ensure_test_header() -> Result<(), String> {
     Ok(())
 }
 
+/// Extracts test case names from a C source file by parsing TEST_CASE macros.
 fn extract_test_names_path(path: &Path) -> Vec<String> {
     let Ok(content) = fs::read_to_string(path) else {
         return Vec::new();
@@ -379,6 +388,7 @@ fn extract_test_names_path(path: &Path) -> Vec<String> {
     names
 }
 
+/// Prints a test result field with color coding.
 fn print_field(label: &str, value: i32, color: &str) {
     if value == 0 {
         println!("{}:  {}", label, value);

src/cli/tree.rs

@@ -15,14 +15,27 @@
 // You should have received a copy of the GNU General Public License
 // along with this program.  If not, see <https://www.gnu.org/licenses/>.
 
-use crate::core::config::Config;
+use crate::core::build_config::Config;
 use crate::utils::log::error;
-use crate::utils::text::{BOLD_CYAN, printc};
+use crate::utils::text::{BOLD_CYAN, BOLD_GREEN, printc};
 use std::collections::HashSet;
 use std::path::{Path, PathBuf};
 use toml::Value;
 
-pub fn tree(_args: &[String]) -> i32 {
+/// Displays the dependency tree of the current project.
+///
+/// This function checks for the --help flag and prints usage information if present.
+/// Otherwise, it parses the dcr.toml configuration and prints the dependency tree.
+pub fn tree(args: &[String]) -> i32 {
+    if args.first().is_some_and(|a| a == "--help") {
+        printc("USAGE:", BOLD_GREEN);
+        printc("    dcr tree", BOLD_CYAN);
+        println!();
+        printc("DESCRIPTION:", BOLD_GREEN);
+        println!("    Displays the dependency tree of the current project.");
+        return 0;
+    }
+
     let current_dir = std::env::current_dir().unwrap_or_else(|_| PathBuf::from("."));
     let config = match Config::open("dcr.toml") {
         Ok(c) => c,
@@ -53,6 +66,9 @@ pub fn tree(_args: &[String]) -> i32 {
     0
 }
 
+/// Recursively prints the dependency tree starting from the given dependencies table.
+///
+/// Sorts dependencies for consistent ordering and handles path resolution for sub-dependencies.
 fn print_deps(
     deps: &toml::value::Table,
     base_path: &Path,
@@ -72,6 +88,7 @@ fn print_deps(
         let mut sub_deps = None;
         let mut resolved_path = None;
 
+        // Resolve dependency path if it's a path-based dependency
         if let Some(path) = &dep_path {
             let dcr_toml = path.join("dcr.toml");
             if dcr_toml.exists()
@@ -108,6 +125,7 @@ fn print_deps(
 
         println!("{}{}{}{}", prefix, connector, name, version);
 
+        // Recurse only if sub-dependencies exist and this dep hasn't been seen
         if let Some(s_deps) = sub_deps
             && !seen.contains(*name)
         {
@@ -121,6 +139,7 @@ fn print_deps(
     }
 }
 
+/// Resolves the filesystem path for a dependency entry if it specifies a "path:" prefix or table with "path" key.
 fn resolve_dep_path(value: &Value, base_path: &Path) -> Option<PathBuf> {
     match value {
         Value::String(s) => s

src/config.rs

@@ -96,17 +96,8 @@ int main(int argc, char **argv) {
 }
 "#;
 
+/// Returns build flags for the given profile as a static slice, or None if empty.
 pub fn flags(profile: &str) -> Option<&'static [&'static str]> {
-    match profile {
+    let f = crate::utils::build::default_profile_flags(profile);
-        "release" => Some(&["-O3", "-DNDEBUG"]),
+    if f.is_empty() { None } else { Some(f) }
-        "debug" => Some(&[
-            "-O0",
-            "-g",
-            "-Wall",
-            "-Wextra",
-            "-fno-omit-frame-pointer",
-            "-DDCR_DEBUG",
-        ]),
-        _ => None,
-    }
 }

src/core/build/archive.rs

@@ -0,0 +1,276 @@
+// DCR — Cargo-like C/C++ project manager.
+//
+// Copyright (C) 2026 Dexoron (Bezotechestvo Vladimir) <main@dexoron.su>
+//
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with this program.  If not, see <https://www.gnu.org/licenses/>.
+
+use crate::core::build_config::ArchiveConfig;
+use fatfs::{FileSystem, FormatVolumeOptions, format_volume};
+use glob::glob;
+use std::fs::{self, File, OpenOptions};
+use std::io::{self, Read, Seek, SeekFrom, Write};
+use std::path::Path;
+
+/// File wrapper that shifts all seek offsets (used to skip the boot sector on a FAT image).
+struct OffsetFile<T> {
+    inner: T,
+    offset: u64,
+}
+
+impl<T: Read> Read for OffsetFile<T> {
+    fn read(&mut self, buf: &mut [u8]) -> io::Result<usize> {
+        self.inner.read(buf)
+    }
+}
+
+impl<T: Write> Write for OffsetFile<T> {
+    fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
+        self.inner.write(buf)
+    }
+    fn flush(&mut self) -> io::Result<()> {
+        self.inner.flush()
+    }
+}
+
+impl<T: Seek> Seek for OffsetFile<T> {
+    fn seek(&mut self, pos: SeekFrom) -> io::Result<u64> {
+        match pos {
+            SeekFrom::Start(n) => {
+                let actual = self.inner.seek(SeekFrom::Start(n + self.offset))?;
+                if actual < self.offset {
+                    Ok(0)
+                } else {
+                    Ok(actual - self.offset)
+                }
+            }
+            SeekFrom::Current(n) => {
+                let actual = self.inner.seek(SeekFrom::Current(n))?;
+                if actual < self.offset {
+                    Ok(0)
+                } else {
+                    Ok(actual - self.offset)
+                }
+            }
+            SeekFrom::End(n) => {
+                let actual = self.inner.seek(SeekFrom::End(n))?;
+                if actual < self.offset {
+                    Ok(0)
+                } else {
+                    Ok(actual - self.offset)
+                }
+            }
+        }
+    }
+}
+
+/// Parses a size string like `1.5m` or `500k` into bytes (1024-based; empty → 0).
+fn parse_size(s: &str) -> Result<u64, String> {
+    let s = s.trim();
+    if s.is_empty() {
+        return Ok(0);
+    }
+    let mut num_str = String::new();
+    let mut unit = String::new();
+    for c in s.chars() {
+        if c.is_ascii_digit() || c == '.' {
+            num_str.push(c);
+        } else {
+            unit.push(c);
+        }
+    }
+    let val: f64 = num_str
+        .parse()
+        .map_err(|_| format!("invalid size number: {num_str}"))?;
+    let unit = unit.trim().to_lowercase();
+    let multiplier = match unit.as_str() {
+        "k" | "kb" => 1024.0,
+        "m" | "mb" => 1024.0 * 1024.0,
+        "g" | "gb" => 1024.0 * 1024.0 * 1024.0,
+        "" => 1.0,
+        _ => return Err(format!("unknown unit: {unit}")),
+    };
+    Ok((val * multiplier) as u64)
+}
+
+/// Creates a FAT image from layout config, substituting `{profile}` and optional boot sector.
+pub fn pack_archive(
+    project_root: &Path,
+    config: &ArchiveConfig,
+    profile: &str,
+) -> Result<(), String> {
+    let output_substituted = config.output.replace("{profile}", profile);
+    let output_path = project_root.join(&output_substituted);
+    if let Some(parent) = output_path.parent() {
+        fs::create_dir_all(parent)
+            .map_err(|e| format!("failed to create output parent dir: {e}"))?;
+    }
+
+    let size = if let Some(sz_str) = &config.size {
+        parse_size(sz_str)?
+    } else {
+        1474560
+    };
+
+    let offset = if let Some(off_str) = &config.offset {
+        parse_size(off_str)?
+    } else {
+        0
+    };
+
+    let mut file = OpenOptions::new()
+        .read(true)
+        .write(true)
+        .create(true)
+        .truncate(false)
+        .open(&output_path)
+        .map_err(|e| format!("failed to open output file: {e}"))?;
+
+    let current_len = file.metadata().map(|m| m.len()).unwrap_or(0);
+    if current_len < size {
+        file.set_len(size)
+            .map_err(|e| format!("failed to set image file size: {e}"))?;
+    }
+
+    if offset == 0
+        && let Some(boot_rel) = &config.bootsector
+    {
+        // Load and write bootsector if present
+        let boot_rel_substituted = boot_rel.replace("{profile}", profile);
+        let boot_path = project_root.join(&boot_rel_substituted);
+        if boot_path.is_file() {
+            let mut boot_file =
+                File::open(&boot_path).map_err(|e| format!("failed to open bootsector: {e}"))?;
+            let mut boot_bytes = vec![0; 512];
+            let _ = boot_file
+                .read(&mut boot_bytes)
+                .map_err(|e| format!("failed to read bootsector: {e}"))?;
+            file.seek(SeekFrom::Start(0))
+                .map_err(|e| format!("failed to seek to start: {e}"))?;
+            file.write_all(&boot_bytes)
+                .map_err(|e| format!("failed to write bootsector: {e}"))?;
+        }
+    }
+
+    file.seek(SeekFrom::Start(0))
+        .map_err(|e| format!("failed to seek to start: {e}"))?;
+
+    let mut wrapper = OffsetFile {
+        inner: file,
+        offset,
+    };
+
+    let label = config.label.as_deref().unwrap_or("VOLUME");
+    let mut label_bytes = [b' '; 11];
+    let bytes_to_copy = label.len().min(11);
+    label_bytes[..bytes_to_copy].copy_from_slice(&label.as_bytes()[..bytes_to_copy]);
+
+    let fat_type = match config.format.to_lowercase().as_str() {
+        "fat12" => Some(fatfs::FatType::Fat12),
+        "fat16" => Some(fatfs::FatType::Fat16),
+        "fat32" => Some(fatfs::FatType::Fat32),
+        _ => None,
+    };
+
+    let mut options = FormatVolumeOptions::new().volume_label(label_bytes);
+    if let Some(t) = fat_type {
+        options = options.fat_type(t);
+    }
+
+    format_volume(&mut wrapper, options)
+        .map_err(|e| format!("failed to format FAT volume: {e}"))?;
+
+    wrapper
+        .seek(SeekFrom::Start(0))
+        .map_err(|e| format!("failed to seek to start after format: {e}"))?;
+
+    let fs = FileSystem::new(wrapper, fatfs::FsOptions::new())
+        .map_err(|e| format!("failed to mount FAT fs: {e}"))?;
+    let root_dir = fs.root_dir();
+
+    for layout in &config.layout {
+        let from_substituted = layout.from.replace("{profile}", profile);
+        let from_pattern = project_root
+            .join(&from_substituted)
+            .to_string_lossy()
+            .to_string();
+
+        let paths = if from_pattern.contains('*') || from_pattern.contains('?') {
+            let mut matched = Vec::new();
+            if let Ok(entries) = glob(&from_pattern) {
+                for path in entries.flatten() {
+                    matched.push(path);
+                }
+            }
+            matched
+        } else {
+            let p = project_root.join(&from_substituted);
+            if p.exists() { vec![p] } else { Vec::new() }
+        };
+
+        for path in paths {
+            if !path.is_file() {
+                continue;
+            }
+            let filename = path.file_name().and_then(|n| n.to_str()).unwrap_or("");
+            if filename.is_empty() {
+                continue;
+            }
+
+            let mut target_filename = filename.to_string();
+            let mut target_dir_str = layout.to.trim_matches('/');
+
+            let is_glob = from_pattern.contains('*') || from_pattern.contains('?');
+            if !is_glob
+                && !layout.to.ends_with('/')
+                && let Some(last_part) = Path::new(&layout.to).file_name().and_then(|n| n.to_str())
+                && last_part.contains('.')
+            {
+                target_filename = last_part.to_string();
+                let parent_path = Path::new(&layout.to).parent().unwrap_or(Path::new(""));
+                target_dir_str = parent_path.to_str().unwrap_or("").trim_matches('/');
+            }
+
+            let mut current_dir = root_dir.clone();
+            if !target_dir_str.is_empty() {
+                let parts = target_dir_str.split('/');
+                for part in parts {
+                    if part.is_empty() {
+                        continue;
+                    }
+                    current_dir = match current_dir.open_dir(part) {
+                        Ok(dir) => dir,
+                        Err(_) => current_dir
+                            .create_dir(part)
+                            .map_err(|e| format!("failed to create dir {part}: {e}"))?,
+                    };
+                }
+            }
+
+            let mut out_file = current_dir
+                .create_file(&target_filename)
+                .map_err(|e| format!("failed to create file {target_filename}: {e}"))?;
+            let mut in_file =
+                File::open(&path).map_err(|e| format!("failed to open input file: {e}"))?;
+            let mut buffer = Vec::new();
+            in_file
+                .read_to_end(&mut buffer)
+                .map_err(|e| format!("failed to read input file: {e}"))?;
+            out_file
+                .write_all(&buffer)
+                .map_err(|e| format!("failed to write to FAT file {target_filename}: {e}"))?;
+        }
+    }
+
+    Ok(())
+}

src/core/build/builder/artifact.rs

@@ -0,0 +1,426 @@
+// DCR — Cargo-like C/C++ project manager.
+//
+// Copyright (C) 2026 Dexoron (Bezotechestvo Vladimir) <main@dexoron.su>
+//
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with this program.  If not, see <https://www.gnu.org/licenses/>.
+
+use crate::core::build::builder::BuildContext;
+use crate::core::build::common;
+use crate::platform;
+use crate::utils::build::is_bare_metal_target;
+use std::path::{Path, PathBuf};
+use std::process::Command;
+use std::time::Instant;
+
+/// Returns the artifact directory path based on the build context.
+pub(crate) fn artifact_dir(ctx: &BuildContext) -> PathBuf {
+    match ctx.target_dir {
+        Some(dir) => Path::new(dir).to_path_buf(),
+        None => Path::new("./target").join(ctx.profile),
+    }
+}
+
+/// Resolves the artifact path for a given kind/profile/name.
+///
+/// # Parameters
+/// - `kind`: Artifact kind (`bin`, `staticlib`, `sharedlib`, `flat-bin`, `efi`, `elf`, …).
+/// - `profile`: Build profile (`debug` / `release` / custom).
+/// - `project_name`: Default basename when `output_filename` is unset.
+/// - `target_dir`: Optional artifact directory override.
+/// - `output_filename` / `output_extension`: Optional name/ext overrides.
+///
+/// # Returns
+/// Relative/absolute path string, or `None` for `none` / `custom` kinds.
+pub fn resolve_artifact_path(
+    kind: &str,
+    profile: &str,
+    project_name: &str,
+    target_dir: Option<&str>,
+    output_filename: Option<&str>,
+    output_extension: Option<&str>,
+) -> Option<String> {
+    if crate::utils::build::is_flat_bin(kind) {
+        let name = output_filename.unwrap_or(project_name);
+        let ext = output_extension.unwrap_or("bin");
+        let file = if ext.is_empty() {
+            name.to_string()
+        } else {
+            format!("{name}.{ext}")
+        };
+        let dir = match target_dir {
+            Some(dir) => Path::new(dir).to_path_buf(),
+            None => Path::new("./target").join(profile),
+        };
+        return Some(dir.join(file).to_string_lossy().to_string());
+    }
+
+    if matches!(kind, "none" | "custom") {
+        return None;
+    }
+
+    let name = output_filename.unwrap_or(project_name);
+    let ext = output_extension.unwrap_or("");
+    let final_name = if ext.is_empty() {
+        name.to_string()
+    } else {
+        format!("{}.{}", name, ext)
+    };
+
+    let path = match kind {
+        "staticlib" => platform::lib_path(profile, &final_name, target_dir),
+        "sharedlib" => platform::shared_lib_path(profile, &final_name, target_dir),
+        "efi" => platform::efi_path(profile, &final_name, target_dir),
+        "elf" => platform::elf_path(profile, &final_name, target_dir),
+        _ => platform::bin_path(profile, &final_name, target_dir),
+    };
+    Some(path)
+}
+
+/// Converts a relative or absolute path to an absolute path by joining with project root if needed.
+pub fn absolute_artifact_path(project_root: &Path, relative_or_abs: &str) -> PathBuf {
+    let p = Path::new(relative_or_abs);
+    let joined = if p.is_absolute() {
+        p.to_path_buf()
+    } else {
+        let stripped = relative_or_abs
+            .strip_prefix("./")
+            .unwrap_or(relative_or_abs);
+        project_root.join(stripped)
+    };
+    crate::utils::fs::canonicalize_path(&joined)
+}
+
+/// Returns the output path for a flat binary artifact.
+pub(crate) fn flat_output_path(ctx: &BuildContext) -> String {
+    let name = ctx.output_filename.unwrap_or(ctx.project_name);
+    let ext = ctx.output_extension.unwrap_or("bin");
+    let file = if ext.is_empty() {
+        name.to_string()
+    } else {
+        format!("{name}.{ext}")
+    };
+    artifact_dir(ctx).join(file).to_string_lossy().to_string()
+}
+
+/// Returns the output path for a flat binary artifact from a source file.
+pub(crate) fn flat_source_output_path(ctx: &BuildContext, source: &str) -> String {
+    let stem = Path::new(source)
+        .file_stem()
+        .and_then(|s| s.to_str())
+        .unwrap_or("out");
+    let ext = ctx.output_extension.unwrap_or("bin");
+    let file = if ext.is_empty() {
+        stem.to_string()
+    } else {
+        format!("{stem}.{ext}")
+    };
+    artifact_dir(ctx).join(file).to_string_lossy().to_string()
+}
+
+// Helper to find a suitable objcopy tool in PATH
+fn resolve_objcopy() -> Result<String, String> {
+    for candidate in ["llvm-objcopy", "objcopy", "gobjcopy"] {
+        if Command::new(candidate)
+            .arg("--version")
+            .output()
+            .map(|o| o.status.success())
+            .unwrap_or(false)
+        {
+            return Ok(candidate.to_string());
+        }
+    }
+    Err(
+        "flat-bin requires llvm-objcopy, objcopy, or gobjcopy in PATH \
+         (install binutils or LLVM tools)"
+            .to_string(),
+    )
+}
+
+/// Converts an object/ELF to a raw binary via `objcopy -O binary` (skips if up to date).
+pub(crate) fn objcopy_binary(ctx: &BuildContext, input: &str, output: &str) -> Result<(), String> {
+    if let Some(parent) = Path::new(output).parent() {
+        std::fs::create_dir_all(parent).map_err(|e| format!("output dir error: {e}"))?;
+    }
+    if !common::needs_rebuild(input, output) {
+        return Ok(());
+    }
+    let tool = resolve_objcopy()?;
+    let mut cmd = Command::new(&tool);
+    cmd.arg("-O").arg("binary").arg(input).arg(output);
+    if ctx.verbose || std::env::var("DCR_DEBUG").is_ok() {
+        eprintln!("[dcr] {:?}", cmd);
+    }
+    common::run_command_sync_output(&mut cmd)
+}
+
+/// Links objects into an intermediate ELF, then converts it to a flat binary via objcopy.
+pub(crate) fn link_flat_binary(
+    ctx: &BuildContext,
+    objects: &[String],
+    default_linker: &str,
+    start_time: Instant,
+) -> Result<f64, String> {
+    let out_path = flat_output_path(ctx);
+    if !common::needs_link(objects, &out_path) {
+        return Ok(common::elapsed_secs(start_time));
+    }
+
+    let intermediate = {
+        let dir = match ctx.target_dir {
+            Some(dir) => Path::new(dir).join("obj"),
+            None => Path::new("./target").join(ctx.profile).join("obj"),
+        };
+        std::fs::create_dir_all(&dir).map_err(|e| format!("obj dir error: {e}"))?;
+        dir.join(format!("{}.flat.elf", ctx.project_name))
+            .to_string_lossy()
+            .to_string()
+    };
+
+    let mut cmd = Command::new(ctx.linker.unwrap_or(default_linker));
+    cmd.arg("-nostdlib").arg("-static");
+    for obj in objects {
+        cmd.arg(obj);
+    }
+    for dir in ctx.lib_dirs {
+        cmd.arg(format!("-L{dir}"));
+    }
+    for lib in ctx.libs {
+        cmd.arg(format!("-l{lib}"));
+    }
+    for flag in ctx.ldflags {
+        cmd.arg(flag);
+    }
+    cmd.arg("-o").arg(&intermediate);
+
+    if ctx.verbose || std::env::var("DCR_DEBUG").is_ok() {
+        eprintln!("[dcr] {:?}", cmd);
+    }
+    let program = cmd.get_program().to_string_lossy().into_owned();
+    let output = cmd.output().map_err(|err| {
+        if err.kind() == std::io::ErrorKind::NotFound {
+            format!("linker not found: {program} (check [toolchain].ld / PATH)")
+        } else {
+            format!("flat-bin link failed: {err}")
+        }
+    })?;
+    if !output.status.success() {
+        let stderr = String::from_utf8_lossy(&output.stderr);
+        let stdout = String::from_utf8_lossy(&output.stdout);
+        return Err(format!(
+            "flat-bin link failed:\nstdout: {stdout}\nstderr: {stderr}"
+        ));
+    }
+
+    objcopy_binary(ctx, &intermediate, &out_path)?;
+    Ok(common::elapsed_secs(start_time))
+}
+
+/// Archives objects into a static library.
+pub(crate) fn archive_static(
+    ctx: &BuildContext,
+    objects: &[String],
+    start_time: Instant,
+) -> Result<f64, String> {
+    let lib_path = platform::lib_path(ctx.profile, ctx.project_name, ctx.target_dir);
+    if !common::needs_link(objects, &lib_path) {
+        return Ok(common::elapsed_secs(start_time));
+    }
+
+    let archiver = ctx
+        .archiver
+        .unwrap_or_else(|| default_archiver(ctx.compiler));
+
+    let mut cmd = Command::new(archiver);
+    if cfg!(target_os = "windows") && is_msvc_lib(archiver) {
+        cmd.arg("/nologo").arg(format!("/OUT:{lib_path}"));
+    } else {
+        cmd.arg("rcs").arg(&lib_path);
+    }
+    for obj in objects {
+        cmd.arg(obj);
+    }
+    run(ctx, cmd, start_time)
+}
+
+/// Links objects into a binary or library based on artifact kind.
+pub(crate) fn link_binary(
+    ctx: &BuildContext,
+    objects: &[String],
+    default_linker: &str,
+    start_time: Instant,
+) -> Result<f64, String> {
+    if crate::utils::build::is_flat_bin(ctx.kind) {
+        return link_flat_binary(ctx, objects, default_linker, start_time);
+    }
+
+    let mut cmd = Command::new(ctx.linker.unwrap_or(default_linker));
+    if ctx.kind == "sharedlib" {
+        if cfg!(target_os = "macos") {
+            cmd.arg("-dynamiclib");
+        } else {
+            cmd.arg("-shared");
+        }
+    }
+    if ctx.kind == "efi" {
+        cmd.arg("-shared");
+        cmd.arg("-nostdlib");
+        cmd.arg("-Wl,-dll");
+        cmd.arg("-Wl,--subsystem,10");
+    } else if ctx.freestanding || is_bare_metal_target(ctx.target) {
+        cmd.arg("-nostdlib");
+        cmd.arg("-static");
+    }
+    for obj in objects {
+        cmd.arg(obj);
+    }
+    for dir in ctx.lib_dirs {
+        cmd.arg(format!("-L{dir}"));
+    }
+    for lib in ctx.libs {
+        cmd.arg(format!("-l{lib}"));
+    }
+    for flag in ctx.ldflags {
+        cmd.arg(flag);
+    }
+
+    let name = ctx.output_filename.unwrap_or(ctx.project_name);
+    let ext = ctx.output_extension.unwrap_or("");
+    let final_name = if ext.is_empty() {
+        name.to_string()
+    } else {
+        format!("{}.{}", name, ext)
+    };
+
+    let out_path = if ctx.kind == "sharedlib" {
+        platform::shared_lib_path(ctx.profile, &final_name, ctx.target_dir)
+    } else if ctx.kind == "efi" {
+        platform::efi_path(ctx.profile, &final_name, ctx.target_dir)
+    } else if ctx.kind == "elf" {
+        platform::elf_path(ctx.profile, &final_name, ctx.target_dir)
+    } else {
+        platform::bin_path(ctx.profile, &final_name, ctx.target_dir)
+    };
+
+    if !common::needs_link(objects, &out_path) {
+        return Ok(common::elapsed_secs(start_time));
+    }
+    cmd.arg("-o").arg(out_path);
+    run(ctx, cmd, start_time)
+}
+
+/// Returns the default archiver name based on compiler and platform.
+fn default_archiver(compiler: &str) -> &'static str {
+    let c = compiler.to_lowercase();
+    if cfg!(target_os = "windows") {
+        if c.contains("cl") && !c.contains("clang") {
+            "lib"
+        } else if c.contains("clang") {
+            "llvm-ar"
+        } else {
+            "ar"
+        }
+    } else {
+        "ar"
+    }
+}
+
+/// Checks if the archiver is an MSVC lib tool.
+fn is_msvc_lib(archiver: &str) -> bool {
+    let a = archiver.to_lowercase();
+    a == "lib" || a == "lib.exe" || a.ends_with("\\lib.exe") || a.ends_with("/lib.exe")
+}
+
+/// Runs a command and handles success/failure with timing.
+fn run(ctx: &BuildContext, mut cmd: Command, start_time: Instant) -> Result<f64, String> {
+    if ctx.verbose || std::env::var("DCR_DEBUG").is_ok() {
+        eprintln!("[dcr] {:?}", cmd);
+    }
+    let program = cmd.get_program().to_string_lossy().into_owned();
+    let output = cmd.output().map_err(|err| {
+        let msg = err.to_string();
+        if err.kind() == std::io::ErrorKind::NotFound {
+            format!("linker not found: {program} (check [toolchain].ld / PATH)")
+        } else {
+            format!("Build failed: {msg}")
+        }
+    })?;
+    if output.status.success() {
+        Ok(common::elapsed_secs(start_time))
+    } else {
+        let stderr = String::from_utf8_lossy(&output.stderr);
+        let stdout = String::from_utf8_lossy(&output.stdout);
+        Err(format!("Build failed:\nstdout: {stdout}\nstderr: {stderr}"))
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    /// Default `bin` kind resolves via platform bin path.
+    #[test]
+    fn resolve_bin_default() {
+        let p = resolve_artifact_path("bin", "debug", "hello", None, None, None).unwrap();
+        assert_eq!(p, platform::bin_path("debug", "hello", None));
+    }
+
+    /// Custom `target_dir` places the binary under that directory.
+    #[test]
+    fn resolve_bin_custom_target_dir() {
+        let p = resolve_artifact_path("bin", "debug", "hello", Some("/out"), None, None).unwrap();
+        let name = if cfg!(windows) { "hello.exe" } else { "hello" };
+        let expected = Path::new("/out").join(name);
+        assert_eq!(p, expected.to_string_lossy());
+    }
+
+    /// `staticlib` kind resolves to a platform static library path.
+    #[test]
+    fn resolve_staticlib() {
+        let p = resolve_artifact_path("staticlib", "release", "mylib", Some("dist"), None, None)
+            .unwrap();
+        let name = if cfg!(windows) {
+            "mylib.lib"
+        } else {
+            "libmylib.a"
+        };
+        let expected = Path::new("dist").join(name);
+        assert_eq!(p, expected.to_string_lossy());
+    }
+
+    /// Custom output filename and extension override the default name.
+    #[test]
+    fn resolve_with_filename_ext() {
+        let p = resolve_artifact_path(
+            "bin",
+            "debug",
+            "pkg",
+            Some("/out"),
+            Some("KERNEL"),
+            Some("ELF"),
+        )
+        .unwrap();
+        assert_eq!(
+            p,
+            std::path::Path::new("/out")
+                .join("KERNEL.ELF")
+                .to_string_lossy()
+        );
+    }
+
+    /// `none` kind has no artifact path.
+    #[test]
+    fn resolve_none_kind() {
+        assert!(resolve_artifact_path("none", "debug", "x", None, None, None).is_none());
+    }
+}

src/core/build/builder/cc_common.rs

@@ -0,0 +1,236 @@
+// DCR — Cargo-like C/C++ project manager.
+//
+// Copyright (C) 2026 Dexoron (Bezotechestvo Vladimir) <main@dexoron.su>
+//
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with this program.  If not, see <https://www.gnu.org/licenses/>.
+
+use crate::core::build::builder::BuildContext;
+use crate::core::build::builder::artifact;
+use crate::core::build::common;
+use crate::utils::build::{is_bare_metal_target, is_compile_only, is_flat_bin};
+use std::fs;
+use std::path::{Path, PathBuf};
+use std::process::Command;
+use std::time::Instant;
+
+/// Compiles C/C++ sources and links/archives by kind (`bin`, libs, `flat-bin`, or compile-only).
+///
+/// Handles Qt preprocessing when enabled. Returns elapsed seconds.
+pub fn build(ctx: &BuildContext) -> Result<f64, String> {
+    let compiler = if ctx.compiler.is_empty() {
+        "cc"
+    } else {
+        ctx.compiler
+    };
+    // Reject unsupported flat-bin with Qt
+    if is_flat_bin(ctx.kind) && ctx.qt {
+        return Err("flat-bin is not supported with build.qt = true".to_string());
+    }
+    let start_time = Instant::now();
+    let obj_dir = match ctx.target_dir {
+        Some(dir) => Path::new(dir).join("obj"),
+        None => Path::new("./target").join(ctx.profile).join("obj"),
+    };
+    let qt_include_path = if ctx.qt {
+        crate::core::build::language::cxx::qt::process_qt(ctx, &obj_dir)?
+    } else {
+        None
+    };
+
+    let mut all_source_roots = ctx.source_roots.to_vec();
+    if let Some(qt_path) = &qt_include_path {
+        all_source_roots.push(qt_path.clone());
+    }
+
+    let extensions = source_extensions(ctx.language);
+    let sources = common::collect_sources(
+        &all_source_roots,
+        &extensions,
+        ctx.exclude_dirs,
+        ctx.include_paths,
+    )?;
+    let objects = build_objects(compiler, &sources, &obj_dir, ctx, "o", qt_include_path)?;
+
+    if is_compile_only(ctx.kind) && !is_flat_bin(ctx.kind) {
+        return Ok(common::elapsed_secs(start_time));
+    }
+
+    if ctx.kind == "staticlib" {
+        return artifact::archive_static(ctx, &objects, start_time);
+    }
+
+    artifact::link_binary(ctx, &objects, compiler, start_time)
+}
+
+/// Collects source files from the provided source roots for the build context.
+///
+/// Delegates to common source collection after resolving language-specific extensions.
+pub(crate) fn collect_sources(ctx: &BuildContext) -> Result<Vec<String>, String> {
+    let extensions = source_extensions(ctx.language);
+    common::collect_sources(
+        ctx.source_roots,
+        &extensions,
+        ctx.exclude_dirs,
+        ctx.include_paths,
+    )
+}
+
+/// Source file extensions for `language` (owned `Vec` of static slices).
+fn source_extensions(language: &str) -> Vec<&'static str> {
+    crate::core::build::common::source_extensions(language)
+}
+
+/// Retrieves default compiler flags for the specified build profile.
+fn default_flags(profile: &str) -> &'static [&'static str] {
+    crate::utils::build::default_profile_flags(profile)
+}
+
+/// Compiles all provided sources into object files in parallel.
+///
+/// Prepares object file paths and spawns parallel tasks for each source compilation.
+fn build_objects(
+    compiler: &str,
+    sources: &[String],
+    obj_dir: &Path,
+    ctx: &BuildContext,
+    obj_ext: &str,
+    qt_include_dir: Option<PathBuf>,
+) -> Result<Vec<String>, String> {
+    let objects: Vec<String> = sources
+        .iter()
+        .map(|s| common::object_path(obj_dir, s, obj_ext))
+        .collect();
+
+    // Compile objects in parallel
+    common::parallel_build(
+        sources.len(),
+        |i| {
+            build_object(
+                compiler,
+                &sources[i],
+                &objects[i],
+                ctx,
+                qt_include_dir.as_deref(),
+            )
+        },
+        ctx.codegen_units,
+    )?;
+
+    Ok(objects)
+}
+
+/// Compiles a single source file to an object file.
+///
+/// Creates object directory if needed, checks for rebuild necessity, constructs and runs the compiler command with appropriate flags.
+fn build_object(
+    compiler: &str,
+    source: &str,
+    obj_path: &str,
+    ctx: &BuildContext,
+    qt_include_dir: Option<&Path>,
+) -> Result<(), String> {
+    if let Some(parent) = Path::new(obj_path).parent() {
+        fs::create_dir_all(parent).map_err(|err| format!("obj dir error: {err}"))?;
+    }
+
+    // Skip if object is already up to date
+    if !common::needs_rebuild(source, obj_path) {
+        return Ok(());
+    }
+
+    let mut cmd = Command::new(compiler);
+    cmd.arg("-c");
+
+    if let Some(flag) = asm_lang_flag(source) {
+        cmd.arg("-x").arg(flag);
+    }
+
+    cmd.arg(source).arg("-o").arg(obj_path);
+
+    if ctx.kind == "sharedlib" {
+        cmd.arg("-fPIC");
+    }
+
+    if (ctx.freestanding || is_bare_metal_target(ctx.target) || is_flat_bin(ctx.kind))
+        && ctx.language.to_lowercase() != "asm"
+    {
+        cmd.arg("-ffreestanding");
+    }
+
+    if ctx.panic_abort && ctx.language.to_lowercase() != "asm" {
+        if ctx.language.contains("++")
+            || ctx.language.contains("cpp")
+            || ctx.language.contains("cxx")
+        {
+            cmd.arg("-fno-exceptions");
+        }
+        cmd.arg("-fno-unwind-tables");
+        cmd.arg("-fno-asynchronous-unwind-tables");
+    }
+
+    if let Some(platform) = ctx.platform
+        && !platform.trim().is_empty()
+    {
+        cmd.arg(format!("-march={}", platform));
+    }
+
+    if !ctx.standard.is_empty() && ctx.language.to_lowercase() != "asm" {
+        let ext = Path::new(source)
+            .extension()
+            .and_then(|e| e.to_str())
+            .unwrap_or("");
+        let is_cpp = matches!(ext, "cpp" | "cxx" | "cc");
+        if is_cpp && !ctx.cxx_standard.is_empty() {
+            cmd.arg(format!("-std={}", ctx.cxx_standard));
+        } else if !is_cpp {
+            cmd.arg(format!("-std={}", ctx.standard));
+        }
+    }
+
+    let use_dcr_defaults = ctx.cflags.is_empty()
+        && !(ctx.freestanding || is_bare_metal_target(ctx.target) || is_flat_bin(ctx.kind));
+
+    // Use default flags only if no custom flags and not special target
+    if use_dcr_defaults {
+        for flag in default_flags(ctx.profile) {
+            cmd.arg(flag);
+        }
+    }
+
+    for flag in ctx.cflags {
+        cmd.arg(flag);
+    }
+
+    for dir in ctx.include_dirs {
+        cmd.arg(format!("-I{dir}"));
+    }
+
+    if let Some(path) = qt_include_dir {
+        cmd.arg(format!("-I{}", path.display()));
+    }
+
+    let d_path = Path::new(obj_path).with_extension("d");
+    cmd.arg("-MMD").arg("-MF").arg(&d_path);
+
+    if ctx.verbose || std::env::var("DCR_DEBUG").is_ok() {
+        eprintln!("[dcr] {:?}", cmd);
+    }
+
+    common::run_command_sync_output(&mut cmd)
+}
+
+/// Returns the assembly language flag for the compiler based on source extension.
+fn asm_lang_flag(source: &str) -> Option<&'static str> {
+    crate::core::build::common::asm_lang_flag(source)
+}

src/core/build/builder/mod.rs

@@ -0,0 +1,249 @@
+// DCR — Cargo-like C/C++ project manager.
+//
+// Copyright (C) 2026 Dexoron (Bezotechestvo Vladimir) <main@dexoron.su>
+//
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with this program.  If not, see <https://www.gnu.org/licenses/>.
+
+pub mod artifact;
+pub mod cc_common;
+pub mod msvc;
+
+use crate::core::build::language::asm::{fasm, gas, masm, nasm};
+use crate::core::build::language::llvm_ir;
+
+/// Configuration context for the build process, including compiler, target, and output settings.
+pub struct BuildContext<'a> {
+    pub profile: &'a str,
+    pub project_name: &'a str,
+    pub compiler: &'a str,
+    pub language: &'a str,
+    pub standard: &'a str,
+    pub cxx_standard: &'a str,
+    pub target: Option<&'a str>,
+    pub target_dir: Option<&'a str>,
+    pub kind: &'a str,
+    pub platform: Option<&'a str>,
+    pub linker: Option<&'a str>,
+    pub archiver: Option<&'a str>,
+    pub moc: Option<&'a str>,
+    pub uic: Option<&'a str>,
+    pub rcc: Option<&'a str>,
+    pub package_type: Option<&'a str>,
+    pub freestanding: bool,
+    pub panic_abort: bool,
+    pub codegen_units: usize,
+    pub source_roots: &'a [std::path::PathBuf],
+    pub exclude_dirs: &'a [std::path::PathBuf],
+    pub include_paths: &'a [String],
+    pub include_dirs: &'a [String],
+    pub lib_dirs: &'a [String],
+    pub libs: &'a [String],
+    pub cflags: &'a [String],
+    pub ldflags: &'a [String],
+    pub output_filename: Option<&'a str>,
+    pub output_extension: Option<&'a str>,
+    pub verbose: bool,
+    pub qt: bool,
+}
+
+/// Trait defining the build interface for different compilers and languages.
+pub trait Builder {
+    #[allow(dead_code)]
+    fn id(&self) -> &'static str;
+    fn build(&self, ctx: &BuildContext) -> Result<f64, String>;
+    fn collect_sources(&self, ctx: &BuildContext) -> Result<Vec<String>, String>;
+}
+
+/// Concrete builder for C/C++ languages using gcc/clang.
+struct Cc;
+/// Concrete builder for MSVC and clang-cl.
+struct Msvc;
+/// Concrete builder for NASM assembly.
+struct Nasm;
+/// Concrete builder for GNU Assembler (gas).
+struct Gas;
+/// Concrete builder for MASM assembler.
+struct Masm;
+/// Concrete builder for FASM assembler.
+struct Fasm;
+/// Concrete builder for LLVM IR.
+struct Llc;
+
+impl Builder for Cc {
+    fn id(&self) -> &'static str {
+        "cc"
+    }
+    fn build(&self, ctx: &BuildContext) -> Result<f64, String> {
+        cc_common::build(ctx)
+    }
+    fn collect_sources(&self, ctx: &BuildContext) -> Result<Vec<String>, String> {
+        cc_common::collect_sources(ctx)
+    }
+}
+
+impl Builder for Msvc {
+    fn id(&self) -> &'static str {
+        "msvc"
+    }
+    fn build(&self, ctx: &BuildContext) -> Result<f64, String> {
+        msvc::build(ctx)
+    }
+    fn collect_sources(&self, ctx: &BuildContext) -> Result<Vec<String>, String> {
+        msvc::collect_sources(ctx)
+    }
+}
+
+impl Builder for Nasm {
+    fn id(&self) -> &'static str {
+        "nasm"
+    }
+    fn build(&self, ctx: &BuildContext) -> Result<f64, String> {
+        nasm::build(ctx)
+    }
+    fn collect_sources(&self, ctx: &BuildContext) -> Result<Vec<String>, String> {
+        nasm::collect_sources(ctx)
+    }
+}
+
+impl Builder for Gas {
+    fn id(&self) -> &'static str {
+        "gas"
+    }
+    fn build(&self, ctx: &BuildContext) -> Result<f64, String> {
+        gas::build(ctx)
+    }
+    fn collect_sources(&self, ctx: &BuildContext) -> Result<Vec<String>, String> {
+        gas::collect_sources(ctx)
+    }
+}
+
+impl Builder for Masm {
+    fn id(&self) -> &'static str {
+        "masm"
+    }
+    fn build(&self, ctx: &BuildContext) -> Result<f64, String> {
+        masm::build(ctx)
+    }
+    fn collect_sources(&self, ctx: &BuildContext) -> Result<Vec<String>, String> {
+        masm::collect_sources(ctx)
+    }
+}
+
+impl Builder for Fasm {
+    fn id(&self) -> &'static str {
+        "fasm"
+    }
+    fn build(&self, ctx: &BuildContext) -> Result<f64, String> {
+        fasm::build(ctx)
+    }
+    fn collect_sources(&self, ctx: &BuildContext) -> Result<Vec<String>, String> {
+        fasm::collect_sources(ctx)
+    }
+}
+
+impl Builder for Llc {
+    fn id(&self) -> &'static str {
+        "llvm_ir"
+    }
+    fn build(&self, ctx: &BuildContext) -> Result<f64, String> {
+        llvm_ir::build(ctx)
+    }
+    fn collect_sources(&self, ctx: &BuildContext) -> Result<Vec<String>, String> {
+        llvm_ir::collect_sources(ctx)
+    }
+}
+
+pub fn builder_for(compiler: &str) -> &'static dyn Builder {
+    // Normalize compiler name to lowercase for matching.
+    let c = compiler.to_lowercase();
+    if c.contains("clang-cl") {
+        return &Msvc;
+    }
+    if c == "as" || c.contains("gas") {
+        return &Gas;
+    }
+    if c.contains("llc") {
+        return &Llc;
+    }
+    if c.contains("fasm") {
+        return &Fasm;
+    }
+    if c.contains("nasm") {
+        return &Nasm;
+    }
+    if c == "ml" || c == "ml64" || c.contains("masm") {
+        return &Masm;
+    }
+    if c == "cl" || c.contains("msvc") {
+        return &Msvc;
+    }
+    &Cc
+}
+
+/// Main build entrypoint that validates the compiler and delegates to the selected builder.
+pub fn build(ctx: &BuildContext) -> Result<f64, String> {
+    if !check_compiler_exists(ctx.compiler) {
+        return Err(format!(
+            "Compiler not found: {}. Make sure it is installed and available in PATH.",
+            ctx.compiler
+        ));
+    }
+    // Delegate to the concrete builder's build method.
+    builder_for(ctx.compiler).build(ctx)
+}
+
+/// True if `compiler --version` can be spawned (exit status is ignored).
+fn check_compiler_exists(compiler: &str) -> bool {
+    let name = if compiler.is_empty() {
+        "cc"
+    } else {
+        match compiler.to_lowercase().as_str() {
+            "gas" | "gnu-as" => "as",
+            "nasm" => "nasm",
+            "fasm" | "fasm64" => "fasm",
+            "masm" | "ml" | "ml64" => "ml",
+            _ => compiler,
+        }
+    };
+    std::process::Command::new(name)
+        .arg("--version")
+        .output()
+        .is_ok()
+}
+
+/// Collects source code files by delegating to the builder selected for the compiler.
+pub fn collect_sources(ctx: &BuildContext) -> Result<Vec<String>, String> {
+    builder_for(ctx.compiler).collect_sources(ctx)
+}
+
+/// Unit test verifying that builder_for correctly identifies the builder for various compiler names.
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn builder_resolves_by_compiler_name() {
+        assert_eq!(builder_for("gcc").id(), "cc");
+        assert_eq!(builder_for("clang").id(), "cc");
+        assert_eq!(builder_for("clang++").id(), "cc");
+        assert_eq!(builder_for("").id(), "cc");
+        assert_eq!(builder_for("nasm").id(), "nasm");
+        assert_eq!(builder_for("as").id(), "gas");
+        assert_eq!(builder_for("llc-18").id(), "llvm_ir");
+        assert_eq!(builder_for("fasm").id(), "fasm");
+        assert_eq!(builder_for("ml64").id(), "masm");
+        assert_eq!(builder_for("cl").id(), "msvc");
+        assert_eq!(builder_for("clang-cl").id(), "msvc");
+    }
+}

src/core/build/builder/msvc/mod.rs

@@ -15,14 +15,22 @@
 // You should have received a copy of the GNU General Public License
 // along with this program.  If not, see <https://www.gnu.org/licenses/>.
 
-use crate::core::builder::BuildContext;
+/// MSVC build backend for DCR.
-use crate::core::builder::common;
+///
+/// This module provides the MSVC-specific build implementation for C and C++
+/// projects, including object compilation and linking for executables, static
+/// libraries, shared libraries, and flat binaries.
+use crate::core::build::builder::BuildContext;
+use crate::core::build::builder::artifact;
+use crate::core::build::common;
 use crate::platform;
+use crate::utils::build::{is_compile_only, is_flat_bin};
 use std::fs;
 use std::path::Path;
 use std::process::Command;
 use std::time::Instant;
 
+/// Builds the project target using the MSVC compiler.
 pub fn build(ctx: &BuildContext) -> Result<f64, String> {
     let compiler = if ctx.compiler.is_empty() {
         "cl"
@@ -33,6 +41,9 @@ pub fn build(ctx: &BuildContext) -> Result<f64, String> {
     if lang.contains("asm") {
         return Err("MSVC backend does not support build.language with asm".to_string());
     }
+    if is_flat_bin(ctx.kind) && ctx.qt {
+        return Err("flat-bin is not supported with build.qt = true".to_string());
+    }
     let start_time = Instant::now();
     let sources = collect_sources(ctx)?;
     let obj_dir = match ctx.target_dir {
@@ -41,14 +52,27 @@ pub fn build(ctx: &BuildContext) -> Result<f64, String> {
     };
     let objects = build_objects(compiler, &sources, &obj_dir, ctx, "obj")?;
 
+    if is_compile_only(ctx.kind) && !is_flat_bin(ctx.kind) {
+        return Ok(common::elapsed_secs(start_time));
+    }
+
+    if is_flat_bin(ctx.kind) {
+        return link_flat_msvc(ctx, compiler, &objects, &obj_dir, start_time);
+    }
+
     if ctx.kind == "staticlib" {
         let lib_path = platform::lib_path(ctx.profile, ctx.project_name, ctx.target_dir);
         if !common::needs_link(&objects, &lib_path) {
-            let elapsed = ((start_time.elapsed().as_secs_f64() * 100.0).trunc()) / 100.0;
+            let elapsed = common::elapsed_secs(start_time);
             return Ok(elapsed);
         }
-        let mut cmd = Command::new(ctx.archiver.unwrap_or("lib"));
+        let archiver = ctx.archiver.unwrap_or("lib");
-        cmd.arg("/nologo").arg(format!("/OUT:{lib_path}"));
+        let mut cmd = Command::new(archiver);
+        if archiver == "lib" || archiver.eq_ignore_ascii_case("lib.exe") {
+            cmd.arg("/nologo").arg(format!("/OUT:{lib_path}"));
+        } else {
+            cmd.arg("rcs").arg(&lib_path);
+        }
         for obj in &objects {
             cmd.arg(obj);
         }
@@ -57,7 +81,7 @@ pub fn build(ctx: &BuildContext) -> Result<f64, String> {
         }
         match cmd.status() {
             Ok(status) if status.success() => {
-                let elapsed = ((start_time.elapsed().as_secs_f64() * 100.0).trunc()) / 100.0;
+                let elapsed = common::elapsed_secs(start_time);
                 return Ok(elapsed);
             }
             Ok(_) => return Err("Build failed".to_string()),
@@ -123,17 +147,17 @@ pub fn build(ctx: &BuildContext) -> Result<f64, String> {
     };
 
     if !common::needs_link(&objects, &out_path) {
-        let elapsed = ((start_time.elapsed().as_secs_f64() * 100.0).trunc()) / 100.0;
+        let elapsed = common::elapsed_secs(start_time);
         return Ok(elapsed);
     }
-    cmd.arg(format!("/Fe:{out_path}"));
+    cmd.arg("-o").arg(out_path);
 
     if ctx.verbose || std::env::var("DCR_DEBUG").is_ok() {
         eprintln!("[dcr] {:?}", cmd);
     }
     match cmd.status() {
         Ok(status) if status.success() => {
-            let elapsed = ((start_time.elapsed().as_secs_f64() * 100.0).trunc()) / 100.0;
+            let elapsed = common::elapsed_secs(start_time);
             Ok(elapsed)
         }
         Ok(_) => Err("Build failed".to_string()),
@@ -141,6 +165,63 @@ pub fn build(ctx: &BuildContext) -> Result<f64, String> {
     }
 }
 
+/// Links the flat binary output for MSVC build targets.
+fn link_flat_msvc(
+    ctx: &BuildContext,
+    compiler: &str,
+    objects: &[String],
+    obj_dir: &Path,
+    start_time: Instant,
+) -> Result<f64, String> {
+    let out_path = artifact::flat_output_path(ctx);
+    if !common::needs_link(objects, &out_path) {
+        return Ok(common::elapsed_secs(start_time));
+    }
+    fs::create_dir_all(obj_dir).map_err(|e| format!("obj dir error: {e}"))?;
+    let intermediate = obj_dir
+        .join(format!("{}.flat.exe", ctx.project_name))
+        .to_string_lossy()
+        .to_string();
+
+    let mut cmd = Command::new(compiler);
+    cmd.arg("/nologo");
+    for obj in objects {
+        cmd.arg(obj);
+    }
+    for flag in ctx.cflags {
+        cmd.arg(flag);
+    }
+    for dir in ctx.lib_dirs {
+        cmd.arg(format!("/LIBPATH:{dir}"));
+    }
+    for lib in ctx.libs {
+        if lib.to_lowercase().ends_with(".lib") {
+            cmd.arg(lib);
+        } else {
+            cmd.arg(format!("{lib}.lib"));
+        }
+    }
+    cmd.arg(format!("/Fe:{intermediate}"));
+    if !ctx.ldflags.is_empty() {
+        cmd.arg("/link");
+        for flag in ctx.ldflags {
+            cmd.arg(flag);
+        }
+    }
+    if ctx.verbose || std::env::var("DCR_DEBUG").is_ok() {
+        eprintln!("[dcr] {:?}", cmd);
+    }
+    let status = cmd
+        .status()
+        .map_err(|e| format!("flat-bin link failed: {e}"))?;
+    if !status.success() {
+        return Err("flat-bin link failed".to_string());
+    }
+    artifact::objcopy_binary(ctx, &intermediate, &out_path)?;
+    Ok(common::elapsed_secs(start_time))
+}
+
+/// Collects all source files for the build based on language extensions.
 pub(crate) fn collect_sources(ctx: &BuildContext) -> Result<Vec<String>, String> {
     let extensions = source_extensions(ctx.language);
     common::collect_sources(
@@ -151,23 +232,12 @@ pub(crate) fn collect_sources(ctx: &BuildContext) -> Result<Vec<String>, String>
     )
 }
 
-fn source_extensions(language: &str) -> Vec<&str> {
+/// Source file extensions for `language` (owned `Vec` of static slices).
-    let mut out = Vec::new();
+fn source_extensions(language: &str) -> Vec<&'static str> {
-    for part in language.split(',').map(|s| s.trim()) {
+    crate::core::build::common::source_extensions(language)
-        let lang = part.to_lowercase();
-        match lang.as_str() {
-            "c" => out.extend(["c"]),
-            "c++" | "cpp" | "cxx" => out.extend(["cpp", "cxx", "cc"]),
-            "asm" => {}
-            _ => {}
-        }
-    }
-    if out.is_empty() {
-        out.extend(["c"]);
-    }
-    out
 }
 
+/// Maps the language and standard version to the corresponding MSVC flag string.
 fn msvc_standard_flag(language: &str, standard: &str) -> Result<String, String> {
     let lang = language.to_lowercase();
     let std = standard.to_lowercase();
@@ -191,6 +261,7 @@ fn msvc_standard_flag(language: &str, standard: &str) -> Result<String, String>
     Err("Unsupported language".to_string())
 }
 
+/// Returns the MSVC architecture flag based on the target platform.
 fn msvc_arch_flag(platform: Option<&str>) -> Option<&'static str> {
     let raw = platform?.trim();
     if raw.is_empty() {
@@ -208,6 +279,7 @@ fn msvc_arch_flag(platform: Option<&str>) -> Option<&'static str> {
     }
 }
 
+/// Returns default compiler flags for the specified build profile.
 fn default_flags(profile: &str) -> &'static [&'static str] {
     match profile {
         "release" => &["/O2", "/DNDEBUG"],
@@ -216,6 +288,7 @@ fn default_flags(profile: &str) -> &'static [&'static str] {
     }
 }
 
+/// Compiles all sources into object files using parallel processing.
 fn build_objects(
     compiler: &str,
     sources: &[String],
@@ -228,13 +301,16 @@ fn build_objects(
         .map(|s| common::object_path(obj_dir, s, obj_ext))
         .collect();
 
-    common::parallel_build(sources.len(), |i| {
+    common::parallel_build(
-        build_object(compiler, &sources[i], &objects[i], ctx)
+        sources.len(),
-    })?;
+        |i| build_object(compiler, &sources[i], &objects[i], ctx),
+        ctx.codegen_units,
+    )?;
 
     Ok(objects)
 }
 
+/// Compiles a single source file to an object file.
 fn build_object(
     compiler: &str,
     source: &str,
@@ -307,6 +383,7 @@ fn build_object(
     let mut headers = Vec::new();
     let mut clean_stdout = String::new();
 
+    // Parse compiler output to extract include file notes for dependency generation
     for line in stdout.lines() {
         if let Some(stripped) = line.strip_prefix("Note: including file:") {
             headers.push(stripped.trim().to_string());

src/core/build/cache.rs

@@ -0,0 +1,284 @@
+// DCR — Cargo-like C/C++ project manager.
+//
+// Copyright (C) 2026 Dexoron (Bezotechestvo Vladimir) <main@dexoron.su>
+//
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with this program.  If not, see <https://www.gnu.org/licenses/>.
+
+use crate::core::build::builder::BuildContext;
+use crate::core::build::common;
+use sha2::{Digest, Sha256};
+use std::fs;
+use std::path::{Path, PathBuf};
+
+/// Computes a build fingerprint by hashing context fields and file metadata (SHA-256).
+///
+/// Includes `dcr.toml` (required) and `dcr.lock` when present, plus path/size/mtime
+/// for each source, header, and library file.
+///
+/// # Parameters
+/// - `ctx`: Build context (profile, tools, flags, dirs, …).
+/// - `sources` / `headers` / `lib_files`: Inputs whose metadata enters the hash.
+///
+/// # Returns
+/// Hex-encoded fingerprint, or an error if `dcr.toml` or a listed file cannot be read.
+pub(crate) fn compute_build_fingerprint(
+    ctx: &BuildContext,
+    sources: &[String],
+    headers: &[PathBuf],
+    lib_files: &[PathBuf],
+) -> Result<String, String> {
+    let mut hasher = Sha256::new();
+    hasher.update(ctx.profile.as_bytes());
+    hasher.update(ctx.project_name.as_bytes());
+    hasher.update(ctx.compiler.as_bytes());
+    hasher.update(ctx.language.as_bytes());
+    hasher.update(ctx.standard.as_bytes());
+    hasher.update(ctx.kind.as_bytes());
+    if let Some(v) = ctx.target_dir {
+        hasher.update(v.as_bytes());
+    }
+    if let Some(v) = ctx.platform {
+        hasher.update(v.as_bytes());
+    }
+    if let Some(v) = ctx.linker {
+        hasher.update(v.as_bytes());
+    }
+    if let Some(v) = ctx.archiver {
+        hasher.update(v.as_bytes());
+    }
+    for value in ctx.include_dirs {
+        hasher.update(value.as_bytes());
+    }
+    for value in ctx.lib_dirs {
+        hasher.update(value.as_bytes());
+    }
+    for value in ctx.libs {
+        hasher.update(value.as_bytes());
+    }
+    for value in ctx.cflags {
+        hasher.update(value.as_bytes());
+    }
+    for value in ctx.ldflags {
+        hasher.update(value.as_bytes());
+    }
+    // Include project metadata from dcr.toml in the fingerprint
+    let toml =
+        fs::read_to_string("dcr.toml").map_err(|err| format!("Failed to read dcr.toml: {err}"))?;
+    hasher.update(toml.as_bytes());
+    if let Ok(lock) = fs::read_to_string("dcr.lock") {
+        hasher.update(lock.as_bytes());
+    }
+    // Include source, header, and library files in the fingerprint
+    for source in sources {
+        let path = Path::new(source);
+        update_hasher_with_file(&mut hasher, path)?;
+    }
+    for header in headers {
+        update_hasher_with_file(&mut hasher, header)?;
+    }
+    for lib in lib_files {
+        update_hasher_with_file(&mut hasher, lib)?;
+    }
+    Ok(to_hex(&hasher.finalize()))
+}
+
+/// Whether the build can be skipped: main artifact exists and cache hash matches.
+///
+/// # Parameters
+/// - `ctx`: Used to locate the output artifact and `.dcr-build.hash`.
+/// - `fingerprint`: Fresh hash from [`compute_build_fingerprint`].
+///
+/// # Returns
+/// `true` only when both the artifact and matching cache file are present.
+pub(crate) fn should_skip_build(ctx: &BuildContext, fingerprint: &str) -> bool {
+    let output = build_output_path(ctx);
+    if !Path::new(&output).is_file() {
+        return false;
+    }
+    let cache_path = build_cache_path(ctx.profile, ctx.target_dir);
+    let cached = fs::read_to_string(cache_path).unwrap_or_default();
+    cached.trim() == fingerprint
+}
+
+/// Persists the build fingerprint to the cache file on disk.
+pub(crate) fn write_build_fingerprint(ctx: &BuildContext, fingerprint: &str) -> Result<(), String> {
+    let cache_path = build_cache_path(ctx.profile, ctx.target_dir);
+    if let Some(parent) = cache_path.parent() {
+        fs::create_dir_all(parent).map_err(|err| format!("Failed to create cache dir: {err}"))?;
+    }
+    fs::write(cache_path, format!("{fingerprint}\n"))
+        .map_err(|err| format!("Failed to write cache: {err}"))
+}
+
+/// Returns the path to the build cache hash file based on profile and target directory.
+fn build_cache_path(profile: &str, target_dir: Option<&str>) -> PathBuf {
+    match target_dir {
+        Some(dir) => Path::new(dir).join(".dcr-build.hash"),
+        None => Path::new("./target").join(profile).join(".dcr-build.hash"),
+    }
+}
+
+/// Resolves the output path for the build artifact using the provided context.
+pub fn build_output_path(ctx: &BuildContext) -> String {
+    crate::core::build::builder::artifact::resolve_artifact_path(
+        ctx.kind,
+        ctx.profile,
+        ctx.project_name,
+        ctx.target_dir,
+        ctx.output_filename,
+        ctx.output_extension,
+    )
+    .unwrap_or_else(|| {
+        crate::platform::bin_path(
+            ctx.profile,
+            ctx.output_filename.unwrap_or(ctx.project_name),
+            ctx.target_dir,
+        )
+    })
+}
+
+/// Collects header files from source roots and include directories, filtering out excluded paths.
+pub(crate) fn collect_header_files(
+    ctx: &BuildContext,
+    project_root: &Path,
+) -> Result<Vec<PathBuf>, String> {
+    let mut out = Vec::new();
+    let mut roots = Vec::new();
+    if ctx.source_roots.is_empty() {
+        roots.push(project_root.join("src"));
+    } else {
+        roots.extend(ctx.source_roots.iter().cloned());
+    }
+    let abs_root = project_root
+        .canonicalize()
+        .unwrap_or_else(|_| project_root.to_path_buf());
+    for dir in ctx.include_dirs {
+        let p = Path::new(dir).to_path_buf();
+        if let Ok(abs_p) = p.canonicalize() {
+            if abs_p.starts_with(&abs_root) {
+                roots.push(abs_p);
+            }
+        } else if p.starts_with(&abs_root) {
+            roots.push(p);
+        }
+    }
+    for root in roots {
+        if !root.exists() {
+            continue;
+        }
+        if root.is_file() {
+            if is_header_file(&root) {
+                out.push(root);
+            }
+        } else {
+            collect_header_files_rec(&root, &mut out, ctx.exclude_dirs, ctx.include_paths)?;
+        }
+    }
+    out.sort();
+    out.dedup();
+    Ok(out)
+}
+
+/// Recursively scans a directory to collect header files, respecting exclusion rules.
+fn collect_header_files_rec(
+    dir: &Path,
+    out: &mut Vec<PathBuf>,
+    exclude_dirs: &[PathBuf],
+    include_paths: &[String],
+) -> Result<(), String> {
+    if common::is_excluded(dir, exclude_dirs, include_paths) && include_paths.is_empty() {
+        return Ok(());
+    }
+    for entry in fs::read_dir(dir).map_err(|err| format!("read_dir error: {err}"))? {
+        let entry = entry.map_err(|err| format!("read_dir error: {err}"))?;
+        let path = entry.path();
+        if path.is_dir() {
+            if common::is_excluded(&path, exclude_dirs, include_paths) && include_paths.is_empty() {
+                continue;
+            }
+            collect_header_files_rec(&path, out, exclude_dirs, include_paths)?;
+            continue;
+        }
+        if !path.is_file() {
+            continue;
+        }
+        if common::is_excluded(&path, exclude_dirs, include_paths) {
+            continue;
+        }
+        if is_header_file(&path) {
+            out.push(path);
+        }
+    }
+    Ok(())
+}
+
+/// Checks if the given path has a header file extension.
+fn is_header_file(path: &Path) -> bool {
+    let ext = path.extension().and_then(|v| v.to_str()).unwrap_or("");
+    matches!(ext, "h" | "hpp" | "hh" | "hxx" | "inc")
+}
+
+/// Collects library files from lib directories using platform-specific candidates.
+pub(crate) fn collect_lib_files(ctx: &BuildContext) -> Vec<PathBuf> {
+    let mut out = Vec::new();
+    for dir in ctx.lib_dirs {
+        let dir_path = Path::new(dir);
+        for lib in ctx.libs {
+            for candidate in lib_candidates(lib) {
+                let path = dir_path.join(candidate);
+                if path.is_file() {
+                    out.push(path);
+                }
+            }
+        }
+    }
+    out
+}
+
+/// Candidate library filenames for the **host** OS (`cfg!(target_os = …)`).
+fn lib_candidates(name: &str) -> Vec<String> {
+    if cfg!(target_os = "windows") {
+        return vec![format!("{name}.lib")];
+    }
+    if cfg!(target_os = "macos") {
+        return vec![
+            format!("lib{name}.a"),
+            format!("lib{name}.dylib"),
+            format!("lib{name}.so"),
+        ];
+    }
+    vec![
+        format!("lib{name}.a"),
+        format!("lib{name}.so"),
+        format!("lib{name}.so.0"),
+    ]
+}
+
+/// Updates the hasher with the file's path, size, and last modification time.
+fn update_hasher_with_file(hasher: &mut Sha256, path: &Path) -> Result<(), String> {
+    hasher.update(path.to_string_lossy().as_bytes());
+    let meta = fs::metadata(path).map_err(|err| format!("source read error: {err}"))?;
+    hasher.update(meta.len().to_le_bytes());
+    if let Ok(modified) = meta.modified()
+        && let Ok(duration) = modified.duration_since(std::time::UNIX_EPOCH)
+    {
+        hasher.update(duration.as_nanos().to_le_bytes());
+    }
+    Ok(())
+}
+
+/// Converts a byte slice containing the SHA256 hash to a hexadecimal string.
+fn to_hex(bytes: &[u8]) -> String {
+    crate::utils::fs::to_hex(bytes)
+}

src/core/build/common.rs

@@ -16,16 +16,87 @@
 // along with this program.  If not, see <https://www.gnu.org/licenses/>.
 
 use std::fs;
+use std::io::{self, IsTerminal, Write};
 use std::path::{Path, PathBuf};
 use std::process::Command;
+use std::sync::atomic::{AtomicBool, Ordering};
 use std::sync::{Mutex, OnceLock};
+use std::time::Instant;
 
 static OUTPUT_MUTEX: OnceLock<Mutex<()>> = OnceLock::new();
+static PROGRESS_LABEL: OnceLock<Mutex<Option<String>>> = OnceLock::new();
+static PROGRESS_DIRTY: AtomicBool = AtomicBool::new(false);
 
+/// Returns a static mutex used to synchronize access to stderr during progress reporting.
+/// This ensures thread-safe output when multiple build threads write to the terminal.
 pub fn get_output_lock() -> &'static Mutex<()> {
     OUTPUT_MUTEX.get_or_init(|| Mutex::new(()))
 }
 
+/// Initializes the shared progress label storage.
+fn progress_label_lock() -> &'static Mutex<Option<String>> {
+    PROGRESS_LABEL.get_or_init(|| Mutex::new(None))
+}
+
+/// Sets the label text that will be shown next to the compile progress counter.
+/// The label is cleared after the progress line is finished.
+pub fn set_progress_label(label: Option<String>) {
+    *progress_label_lock().lock().unwrap() = label;
+}
+
+/// Finishes the current progress line by clearing the label and flushing the line if it was dirty.
+/// This is called when a build step completes normally.
+pub fn finish_progress_line() {
+    let was_dirty = PROGRESS_DIRTY.swap(false, Ordering::SeqCst);
+    *progress_label_lock().lock().unwrap() = None;
+    if !was_dirty {
+        return;
+    }
+    if io::stderr().is_terminal() {
+        let _guard = get_output_lock().lock().unwrap();
+        let _ = writeln!(io::stderr());
+        let _ = io::stderr().flush();
+    }
+}
+
+/// Interrupts the current progress line (if any) and flushes it to stderr.
+/// Used when a build step produces output that should interrupt the progress display.
+pub fn interrupt_progress_for_output() {
+    if !PROGRESS_DIRTY.swap(false, Ordering::SeqCst) {
+        return;
+    }
+    if io::stderr().is_terminal() {
+        let _guard = get_output_lock().lock().unwrap();
+        let _ = writeln!(io::stderr());
+        let _ = io::stderr().flush();
+    }
+}
+
+/// Reports the current compile progress to stderr in the format "label [done/total]".
+/// Only prints if the terminal is attached and the label is set.
+/// Updates the dirty flag so the line can be overwritten on the next call.
+fn report_compile_progress(done: usize, total: usize) {
+    let label = progress_label_lock().lock().unwrap().clone();
+    let Some(label) = label else {
+        return;
+    };
+    if !io::stderr().is_terminal() {
+        return;
+    }
+    let _guard = get_output_lock().lock().unwrap();
+    let msg = format!("{label}  [{done}/{total}]");
+    if PROGRESS_DIRTY.load(Ordering::SeqCst) {
+        eprint!("\r{msg:<80}");
+    } else {
+        eprint!("{msg}");
+    }
+    let _ = io::stderr().flush();
+    PROGRESS_DIRTY.store(true, Ordering::SeqCst);
+}
+
+/// Recursively collects all source files under the given roots that match the provided extensions.
+/// Directories listed in exclude_dirs are skipped unless overridden by include_paths.
+/// Returns a sorted list of normalized source paths or an error string.
 pub fn collect_sources(
     roots: &[PathBuf],
     extensions: &[&str],
@@ -34,12 +105,22 @@ pub fn collect_sources(
 ) -> Result<Vec<String>, String> {
     let mut sources = Vec::new();
     for root in roots {
-        collect_sources_rec(root, extensions, &mut sources, exclude_dirs, include_paths)?;
+        if root.is_file() {
+            if let Some(ext) = root.extension().and_then(|e| e.to_str())
+                && extensions.contains(&ext.to_lowercase().as_str())
+            {
+                sources.push(root.to_string_lossy().to_string());
+            }
+        } else {
+            collect_sources_rec(root, extensions, &mut sources, exclude_dirs, include_paths)?;
+        }
     }
     sources.sort();
     Ok(sources)
 }
 
+/// Recursively walks a directory tree to collect source files.
+/// Skips excluded directories unless they are explicitly allowed by include_paths.
 fn collect_sources_rec(
     dir: &Path,
     extensions: &[&str],
@@ -57,9 +138,10 @@ fn collect_sources_rec(
     if is_excluded(&full_dir, exclude_dirs, include_paths) && include_paths.is_empty() {
         return Ok(());
     }
-    let entries = fs::read_dir(&full_dir).map_err(|err| format!("src dir error: {err}"))?;
+    let entries = fs::read_dir(&full_dir)
+        .map_err(|err| format!("src dir error for {:?}: {err}", full_dir))?;
     for entry in entries {
-        let entry = entry.map_err(|err| format!("src dir error: {err}"))?;
+        let entry = entry.map_err(|err| format!("src dir error for {:?}: {err}", full_dir))?;
         let path = entry.path();
         if path.is_dir() {
             if is_excluded(&path, exclude_dirs, include_paths) && include_paths.is_empty() {
@@ -86,6 +168,8 @@ fn collect_sources_rec(
     Ok(())
 }
 
+/// Determines whether a path should be excluded from source collection.
+/// Returns false if the path is explicitly allowed by include_paths (even if it matches an exclude).
 pub fn is_excluded(path: &Path, exclude_dirs: &[PathBuf], include_paths: &[String]) -> bool {
     if matches_patterns(path, include_paths, true) {
         return false;
@@ -93,9 +177,33 @@ pub fn is_excluded(path: &Path, exclude_dirs: &[PathBuf], include_paths: &[Strin
     if matches_patterns(path, include_paths, false) {
         return true;
     }
-    exclude_dirs.iter().any(|dir| path.starts_with(dir))
+    exclude_dirs.iter().any(|dir| path_is_under(path, dir))
 }
 
+/// Checks if a path is under a given prefix, handling both absolute and relative paths
+/// and normalizing Windows-style separators for cross-platform comparison.
+fn path_is_under(path: &Path, prefix: &Path) -> bool {
+    if path.starts_with(prefix) {
+        return true;
+    }
+    match (fs::canonicalize(path), fs::canonicalize(prefix)) {
+        (Ok(p), Ok(pref)) => p.starts_with(pref),
+        _ => {
+            let p = path.to_string_lossy().replace('\\', "/");
+            let pref = prefix.to_string_lossy().replace('\\', "/");
+            if p == pref || p.starts_with(&format!("{pref}/")) {
+                return true;
+            }
+            let p = p.strip_prefix("/private").unwrap_or(&p);
+            let pref = pref.strip_prefix("/private").unwrap_or(&pref);
+            p == pref || p.starts_with(&format!("{pref}/"))
+        }
+    }
+}
+
+/// Matches a path against include/exclude glob and path patterns.
+/// Positive patterns allow files; negative patterns (starting with !) exclude them.
+/// Returns true if the path matches any rule.
 fn matches_patterns(path: &Path, patterns: &[String], positive: bool) -> bool {
     if patterns.is_empty() {
         return false;
@@ -160,21 +268,72 @@ fn matches_patterns(path: &Path, patterns: &[String], positive: bool) -> bool {
     false
 }
 
+/// Returns true if the string contains any glob magic characters (*, ?, or [).
 pub fn has_glob_magic(value: &str) -> bool {
     value.chars().any(|c| matches!(c, '*' | '?' | '['))
 }
 
-pub fn parallel_build<F>(total_tasks: usize, task_fn: F) -> Result<(), String>
+/// Returns a GCC/Clang `-x` language for assembly sources.
+///
+/// # Parameters
+/// - `source`: Source file path (extension decides the dialect).
+///
+/// # Returns
+/// - `Some("assembler-with-cpp")` for `.S`
+/// - `Some("assembler")` for `.s` / `.asm`
+/// - `None` for other extensions
+pub fn asm_lang_flag(source: &str) -> Option<&'static str> {
+    let ext = Path::new(source).extension().and_then(|v| v.to_str())?;
+    match ext {
+        "S" => Some("assembler-with-cpp"),
+        "s" | "asm" => Some("assembler"),
+        _ => None,
+    }
+}
+
+/// Returns the list of file extensions associated with the given language token(s).
+/// Splits comma-separated tokens and falls back to .c if no language is recognized.
+pub fn source_extensions(language: &str) -> Vec<&'static str> {
+    let mut out = Vec::new();
+    for part in language.split(',').map(|s| s.trim()) {
+        if let Some(lang) = crate::core::build::language::language_for_token(part) {
+            out.extend(lang.extensions().iter().copied());
+        }
+    }
+    if out.is_empty() {
+        out.extend(["c"]);
+    }
+    out
+}
+
+/// Returns elapsed time in seconds with two decimal places for display purposes.
+pub fn elapsed_secs(start: Instant) -> f64 {
+    ((start.elapsed().as_secs_f64() * 100.0).trunc()) / 100.0
+}
+
+/// Spawns a fixed number of worker threads to parallelize a build task.
+/// Reports progress after each task completes.
+pub fn parallel_build<F>(total_tasks: usize, task_fn: F, max_jobs: usize) -> Result<(), String>
 where
     F: Fn(usize) -> Result<(), String> + Sync + Send,
 {
-    let num_threads = std::thread::available_parallelism()
+    let available = std::thread::available_parallelism()
         .map(|n| n.get())
         .unwrap_or(1);
+    let num_threads = if max_jobs > 0 {
+        max_jobs.min(available)
+    } else {
+        available
+    };
 
     let counter = std::sync::atomic::AtomicUsize::new(0);
+    let completed = std::sync::atomic::AtomicUsize::new(0);
     let err_msg = std::sync::Mutex::new(None);
 
+    if total_tasks > 0 {
+        report_compile_progress(0, total_tasks);
+    }
+
     std::thread::scope(|s| {
         for _ in 0..num_threads {
             s.spawn(|| {
@@ -195,6 +354,9 @@ where
                         }
                         break;
                     }
+
+                    let done = completed.fetch_add(1, std::sync::atomic::Ordering::Relaxed) + 1;
+                    report_compile_progress(done, total_tasks);
                 }
             });
         }
@@ -207,11 +369,24 @@ where
     Ok(())
 }
 
+/// Runs a command, prints stdout/stderr to the terminal (interrupting progress),
+/// and returns `Ok(())` or `Err` based on exit status.
 pub fn run_command_sync_output(cmd: &mut Command) -> Result<(), String> {
-    let output = cmd.output().map_err(|err| format!("Build failed: {err}"))?;
+    let program = cmd.get_program().to_string_lossy().into_owned();
-    let _guard = OUTPUT_MUTEX.get_or_init(|| Mutex::new(())).lock().unwrap();
+    let output = cmd.output().map_err(|err| {
+        if err.kind() == std::io::ErrorKind::NotFound {
+            format!("{program} not found (check PATH / [toolchain])")
+        } else {
+            format!("Build failed: {err}")
+        }
+    })?;
+    let has_out = !output.stdout.is_empty() || !output.stderr.is_empty();
+    if has_out {
+        interrupt_progress_for_output();
+    }
+    let _guard = get_output_lock().lock().unwrap();
     if !output.stdout.is_empty() {
-        print!("{}", String::from_utf8_lossy(&output.stdout));
+        eprint!("{}", String::from_utf8_lossy(&output.stdout));
     }
     if !output.stderr.is_empty() {
         eprint!("{}", String::from_utf8_lossy(&output.stderr));
@@ -223,6 +398,8 @@ pub fn run_command_sync_output(cmd: &mut Command) -> Result<(), String> {
     }
 }
 
+/// Normalizes a source path to be relative to the current working directory when possible.
+/// Returns the original path unchanged if it cannot be made relative.
 pub fn normalize_source_path(path: &Path) -> String {
     if !path.is_absolute() {
         return path.to_string_lossy().to_string();
@@ -235,6 +412,8 @@ pub fn normalize_source_path(path: &Path) -> String {
     path.to_string_lossy().to_string()
 }
 
+/// Computes the output object file path by stripping the leading ./ and adjusting the extension.
+/// Places the object in the specified obj_dir while preserving directory structure.
 pub fn object_path(obj_dir: &Path, source: &str, obj_ext: &str) -> String {
     let src_path = Path::new(source);
     let stripped = src_path.strip_prefix("./").unwrap_or(src_path);
@@ -264,9 +443,19 @@ pub fn object_path(obj_dir: &Path, source: &str, obj_ext: &str) -> String {
     } else {
         out.set_extension(obj_ext);
     }
-    out.to_string_lossy().to_string()
+    out.to_string_lossy().replace('\\', "/")
 }
 
+/// Checks whether a source file needs to be rebuilt.
+///
+/// Compares mtimes of the source, object, and deps listed in the sibling `.d` file.
+///
+/// # Parameters
+/// - `source`: Source path.
+/// - `object`: Object path (`.d` is derived by changing the extension).
+///
+/// # Returns
+/// `true` if the object is missing, older than source/deps, or a dep is missing.
 pub fn needs_rebuild(source: &str, object: &str) -> bool {
     let src_time = fs::metadata(source).and_then(|m| m.modified());
     let obj_time = fs::metadata(object).and_then(|m| m.modified());
@@ -295,13 +484,21 @@ pub fn needs_rebuild(source: &str, object: &str) -> bool {
                     return true;
                 }
             } else {
-                return true; // Missing dependency triggers rebuild
+                return true;
             }
         }
     }
     false
 }
 
+/// Checks whether the output executable needs to be relinked.
+///
+/// # Parameters
+/// - `objects`: Object file paths that feed the link step.
+/// - `output_path`: Linked artifact path.
+///
+/// # Returns
+/// `true` if the output is missing or any object is newer than it.
 pub fn needs_link(objects: &[String], output_path: &str) -> bool {
     let out_meta = match fs::metadata(output_path) {
         Ok(m) => m,
@@ -327,19 +524,20 @@ pub fn needs_link(objects: &[String], output_path: &str) -> bool {
     false
 }
 
+/// Parses a dependency file (.d) produced by GCC or MSVC compilers.
+/// Extracts all dependency paths, handling escaped newlines and Windows-style paths.
 fn parse_d_file(content: &str) -> Vec<String> {
     let mut deps = Vec::new();
-    let text = content.replace("\\\n", " ").replace("\\\r\n", " ");
     let mut target_end = 0;
-    let chars: Vec<char> = text.chars().collect();
+    let bytes = content.as_bytes();
-    for i in 0..chars.len() {
+    for (i, &b) in bytes.iter().enumerate() {
-        if chars[i] == ':' {
+        if b == b':' {
             if i == 1
-                && chars[0].is_ascii_alphabetic()
+                && bytes[0].is_ascii_alphabetic()
-                && i + 1 < chars.len()
+                && i + 1 < bytes.len()
-                && (chars[i + 1] == '\\' || chars[i + 1] == '/')
+                && (bytes[i + 1] == b'\\' || bytes[i + 1] == b'/')
             {
-                continue; // Windows drive letter
+                continue;
             }
             target_end = i + 1;
             break;
@@ -347,22 +545,32 @@ fn parse_d_file(content: &str) -> Vec<String> {
     }
 
     let deps_str = if target_end > 0 {
-        &text[target_end..]
+        &content[target_end..]
     } else {
-        &text
+        content
     };
 
     let mut current_path = String::new();
     let mut in_escape = false;
+    let mut chars = deps_str.chars().peekable();
 
-    for c in deps_str.chars() {
+    while let Some(c) = chars.next() {
         if in_escape {
-            if c != '\n' && c != '\r' {
+            if c == '\n' {
+            } else if c == '\r' {
+                if chars.peek() == Some(&'\n') {
+                    chars.next();
+                }
+            } else {
                 current_path.push(c);
             }
             in_escape = false;
         } else if c == '\\' {
-            in_escape = true;
+            match chars.peek() {
+                Some('\n' | '\r' | ' ' | '\t' | '\\') => in_escape = true,
+                Some(_) => current_path.push('\\'),
+                None => current_path.push('\\'),
+            }
         } else if c.is_whitespace() {
             if !current_path.is_empty() {
                 deps.push(current_path.clone());
@@ -389,12 +597,18 @@ mod tests {
     static TEST_COUNTER: AtomicUsize = AtomicUsize::new(0);
     static CWD_LOCK: Mutex<()> = Mutex::new(());
 
+    fn cwd_lock() -> std::sync::MutexGuard<'static, ()> {
+        CWD_LOCK
+            .lock()
+            .unwrap_or_else(|poisoned| poisoned.into_inner())
+    }
+
     fn temp_dir(prefix: &str) -> PathBuf {
         let n = TEST_COUNTER.fetch_add(1, Ordering::SeqCst);
         let dir = std::env::temp_dir().join(format!("dcr_test_{prefix}_{n}"));
         let _ = fs::remove_dir_all(&dir);
         fs::create_dir_all(&dir).unwrap();
-        dir
+        fs::canonicalize(&dir).unwrap_or(dir)
     }
 
     fn default_roots() -> Vec<PathBuf> {
@@ -496,7 +710,6 @@ mod tests {
         let src = dir.join("test.c");
         let obj = dir.join("test.o");
         fs::write(&src, "int main() {}").unwrap();
-        // Sleep briefly to ensure mtime difference
         std::thread::sleep(std::time::Duration::from_millis(50));
         fs::write(&obj, "").unwrap();
         assert!(!needs_rebuild(
@@ -560,7 +773,7 @@ mod tests {
         fs::write(src.join("utils.c"), "").unwrap();
         fs::write(src.join("README.md"), "").unwrap(); // should be ignored
 
-        let _guard = CWD_LOCK.lock().unwrap();
+        let _guard = cwd_lock();
         let prev = std::env::current_dir().unwrap();
         std::env::set_current_dir(&dir).unwrap();
         let include: Vec<String> = Vec::new();
@@ -584,7 +797,7 @@ mod tests {
         fs::write(src.join("other.cc"), "").unwrap();
         fs::write(src.join("skip.c"), "").unwrap(); // should be ignored
 
-        let _guard = CWD_LOCK.lock().unwrap();
+        let _guard = cwd_lock();
         let prev = std::env::current_dir().unwrap();
         std::env::set_current_dir(&dir).unwrap();
         let include: Vec<String> = Vec::new();
@@ -602,7 +815,7 @@ mod tests {
         let src = dir.join("src");
         fs::create_dir_all(&src).unwrap();
 
-        let _guard = CWD_LOCK.lock().unwrap();
+        let _guard = cwd_lock();
         let prev = std::env::current_dir().unwrap();
         std::env::set_current_dir(&dir).unwrap();
         let include: Vec<String> = Vec::new();
@@ -624,7 +837,7 @@ mod tests {
         fs::write(vendor.join("lib.c"), "").unwrap(); // should be excluded
 
         let exclude = vec![vendor.clone()];
-        let _guard = CWD_LOCK.lock().unwrap();
+        let _guard = cwd_lock();
         let prev = std::env::current_dir().unwrap();
         std::env::set_current_dir(&dir).unwrap();
         let include: Vec<String> = Vec::new();
@@ -646,7 +859,7 @@ mod tests {
         fs::write(src.join("main.c"), "").unwrap();
         fs::write(sub.join("nested.c"), "").unwrap();
 
-        let _guard = CWD_LOCK.lock().unwrap();
+        let _guard = cwd_lock();
         let prev = std::env::current_dir().unwrap();
         std::env::set_current_dir(&dir).unwrap();
         let include: Vec<String> = Vec::new();
@@ -670,7 +883,7 @@ mod tests {
 
         let exclude = vec![boot.clone()];
         let include = vec!["src/boot/arch/**".to_string()];
-        let _guard = CWD_LOCK.lock().unwrap();
+        let _guard = cwd_lock();
         let prev = std::env::current_dir().unwrap();
         std::env::set_current_dir(&dir).unwrap();
         let roots = default_roots();
@@ -697,7 +910,7 @@ mod tests {
             "!src/legacy/**".to_string(),
             "src/legacy/allow/**".to_string(),
         ];
-        let _guard = CWD_LOCK.lock().unwrap();
+        let _guard = cwd_lock();
         let prev = std::env::current_dir().unwrap();
         std::env::set_current_dir(&dir).unwrap();
         let roots = default_roots();
@@ -720,7 +933,7 @@ mod tests {
 
         let exclude: Vec<PathBuf> = Vec::new();
         let include = vec!["!src/gen/**".to_string()];
-        let _guard = CWD_LOCK.lock().unwrap();
+        let _guard = cwd_lock();
         let prev = std::env::current_dir().unwrap();
         std::env::set_current_dir(&dir).unwrap();
         let roots = default_roots();
@@ -755,35 +968,83 @@ mod tests {
     #[test]
     fn needs_rebuild_header_modified() {
         let dir = temp_dir("rebuild_header");
-        let src = dir.join("test.c");
+        fs::write(dir.join("test.c"), "int main() {}").unwrap();
-        let header = dir.join("test.h");
+        fs::write(dir.join("test.h"), "#define A 1").unwrap();
-        let obj = dir.join("test.o");
+        fs::write(dir.join("test.o"), "").unwrap();
-        let d_file = dir.join("test.d");
 
-        fs::write(&src, "int main() {}").unwrap();
+        let _guard = cwd_lock();
-        fs::write(&header, "#define A 1").unwrap();
+        let prev = std::env::current_dir().unwrap();
-        std::thread::sleep(std::time::Duration::from_millis(50));
+        std::env::set_current_dir(&dir).unwrap();
-        fs::write(&obj, "").unwrap();
-
-        let d_content = format!(
-            "{}: {} {}",
-            obj.to_string_lossy(),
-            src.to_string_lossy(),
-            header.to_string_lossy()
-        );
-        fs::write(&d_file, d_content).unwrap();
 
+        fs::write("test.d", "test.o: test.c missing.h").unwrap();
         assert!(
-            !needs_rebuild(&src.to_string_lossy(), &obj.to_string_lossy()),
+            needs_rebuild("test.c", "test.o"),
-            "should be fresh"
+            "missing dep in .d must force rebuild"
         );
 
-        std::thread::sleep(std::time::Duration::from_millis(50));
+        fs::write("test.h", "#define A 1").unwrap();
-        fs::write(&header, "#define A 2").unwrap(); // modify header
+        std::thread::sleep(std::time::Duration::from_secs(2));
-
+        fs::write("test.o", "obj").unwrap();
+        fs::write("test.d", "test.o: test.c test.h").unwrap();
         assert!(
-            needs_rebuild(&src.to_string_lossy(), &obj.to_string_lossy()),
+            !needs_rebuild("test.c", "test.o"),
+            "object newer than source and headers should be fresh"
+        );
+
+        std::thread::sleep(std::time::Duration::from_secs(2));
+        fs::write("test.h", "#define A 2").unwrap();
+        assert!(
+            needs_rebuild("test.c", "test.o"),
             "changed header should trigger rebuild"
         );
+
+        std::env::set_current_dir(prev).unwrap();
+    }
+
+    #[test]
+    fn parse_d_file_keeps_windows_path_separators() {
+        let content = r"target\obj\main.obj: src\main.c src\utils.h";
+        let deps = parse_d_file(content);
+        assert_eq!(deps, vec![r"src\main.c", r"src\utils.h"]);
+    }
+
+    #[test]
+    fn asm_lang_flag_returns_correct_flag() {
+        assert_eq!(asm_lang_flag("foo.S"), Some("assembler-with-cpp"));
+        assert_eq!(asm_lang_flag("bar.s"), Some("assembler"));
+        assert_eq!(asm_lang_flag("baz.asm"), Some("assembler"));
+        assert_eq!(asm_lang_flag("main.c"), None);
+    }
+
+    #[test]
+    fn source_extensions_parses_language_string() {
+        let c = source_extensions("c");
+        assert!(c.contains(&"c"));
+        assert!(!c.contains(&"cpp"));
+
+        let cpp = source_extensions("c++");
+        assert!(cpp.contains(&"cpp"));
+        assert!(cpp.contains(&"cxx"));
+        assert!(cpp.contains(&"cc"));
+
+        let asm = source_extensions("asm");
+        assert!(asm.contains(&"s"));
+        assert!(asm.contains(&"S"));
+        assert!(asm.contains(&"asm"));
+
+        let mixed = source_extensions("c, c++");
+        assert!(mixed.contains(&"c"));
+        assert!(mixed.contains(&"cpp"));
+
+        let unknown = source_extensions("rust");
+        assert_eq!(unknown, vec!["c"]);
+    }
+
+    #[test]
+    fn elapsed_secs_returns_positive() {
+        let start = std::time::Instant::now();
+        std::thread::sleep(std::time::Duration::from_millis(50));
+        let elapsed = elapsed_secs(start);
+        assert!(elapsed > 0.0);
     }
 }

src/core/build/language/asm/common.rs

@@ -0,0 +1,207 @@
+use crate::core::build::builder::BuildContext;
+use crate::core::build::builder::artifact;
+use crate::core::build::common;
+use crate::utils::build::{is_compile_only, is_flat_bin};
+use std::path::Path;
+use std::time::Instant;
+
+/// Keeps only assembler-relevant flags from a cflags list.
+///
+/// # Parameters
+/// - `flags`: Full compiler flag list (often shared with C/C++).
+///
+/// # Returns
+/// Cloned flags that start with `-I`/`-i` or equal `-g`.
+pub fn filter_asm_flags(flags: &[String]) -> Vec<String> {
+    flags
+        .iter()
+        .filter(|f| {
+            let f = f.as_str();
+            f.starts_with("-I") || f.starts_with("-i") || f == "-g"
+        })
+        .cloned()
+        .collect()
+}
+
+/// Builds assembly sources with direct flat emission when `kind` is `flat-bin`.
+///
+/// For non-flat kinds, assembles to objects and then links/archives as usual.
+///
+/// # Parameters
+/// - `ctx`: Build context (kind, sources, flags, …).
+/// - `backend_name`: Label used in error messages (e.g. `"NASM"`).
+/// - `default_assembler`: Assembler binary when `ctx.compiler` is empty.
+/// - `extensions`: Source extensions to collect.
+/// - `build_object`: Per-source assemble callback `(assembler, src, out, ctx)`.
+///
+/// # Returns
+/// Elapsed seconds, or an error string.
+pub fn build_assembly<F>(
+    ctx: &BuildContext,
+    backend_name: &str,
+    default_assembler: &str,
+    extensions: &[&str],
+    build_object: F,
+) -> Result<f64, String>
+where
+    F: Fn(&str, &str, &str, &BuildContext) -> Result<(), String> + Sync,
+{
+    build_assembly_with_mode(
+        ctx,
+        backend_name,
+        default_assembler,
+        extensions,
+        FlatEmit::Direct,
+        build_object,
+    )
+}
+
+/// Builds assembly sources; for `flat-bin`, assembles to objects then runs objcopy.
+///
+/// For non-flat kinds, assembles to objects and then links/archives as usual.
+///
+/// # Parameters
+/// - Same as [`build_assembly`]; only the flat emission strategy differs.
+///
+/// # Returns
+/// Elapsed seconds, or an error string.
+pub fn build_assembly_via_objcopy<F>(
+    ctx: &BuildContext,
+    backend_name: &str,
+    default_assembler: &str,
+    extensions: &[&str],
+    build_object: F,
+) -> Result<f64, String>
+where
+    F: Fn(&str, &str, &str, &BuildContext) -> Result<(), String> + Sync,
+{
+    build_assembly_with_mode(
+        ctx,
+        backend_name,
+        default_assembler,
+        extensions,
+        FlatEmit::ViaObjcopy,
+        build_object,
+    )
+}
+
+/// Flat-bin emission strategy: direct assembler output, or object then objcopy.
+#[derive(Clone, Copy)]
+enum FlatEmit {
+    Direct,
+    ViaObjcopy,
+}
+
+/// Core assembly build with a chosen flat emission mode; `build_object` runs per source in parallel.
+fn build_assembly_with_mode<F>(
+    ctx: &BuildContext,
+    backend_name: &str,
+    default_assembler: &str,
+    extensions: &[&str],
+    flat_mode: FlatEmit,
+    build_object: F,
+) -> Result<f64, String>
+where
+    F: Fn(&str, &str, &str, &BuildContext) -> Result<(), String> + Sync,
+{
+    let lang = ctx.language.to_lowercase();
+    // Validate language
+    if lang.split(',').any(|p| {
+        let t = p.trim();
+        t != "asm" && t != "llvm_ir" && t != "llvm-ir" && t != "ll"
+    }) {
+        return Err(format!(
+            "{backend_name} backend requires build.language = \"asm\" (or llvm_ir for LLC)"
+        ));
+    }
+
+    let assembler = if ctx.compiler.is_empty() {
+        default_assembler
+    } else {
+        ctx.compiler
+    };
+
+    let start_time = Instant::now();
+    let sources = common::collect_sources(
+        ctx.source_roots,
+        extensions,
+        ctx.exclude_dirs,
+        ctx.include_paths,
+    )?;
+
+    let flat = is_flat_bin(ctx.kind);
+    let obj_dir = match ctx.target_dir {
+        Some(dir) => Path::new(dir).join("obj"),
+        None => Path::new("./target").join(ctx.profile).join("obj"),
+    };
+
+    let objects = match (flat, flat_mode) {
+        // Dispatch based on flat binary kind and emission mode
+        (true, FlatEmit::Direct) => {
+            let outs: Vec<String> = sources
+                .iter()
+                .map(|s| artifact::flat_source_output_path(ctx, s))
+                .collect();
+            common::parallel_build(
+                sources.len(),
+                |i| build_object(assembler, &sources[i], &outs[i], ctx),
+                ctx.codegen_units,
+            )?;
+            outs
+        }
+        (true, FlatEmit::ViaObjcopy) => {
+            let intermediates: Vec<String> = sources
+                .iter()
+                .map(|s| common::object_path(&obj_dir, s, "o"))
+                .collect();
+            common::parallel_build(
+                sources.len(),
+                |i| build_object(assembler, &sources[i], &intermediates[i], ctx),
+                ctx.codegen_units,
+            )?;
+            let mut outs = Vec::with_capacity(sources.len());
+            for (i, src) in sources.iter().enumerate() {
+                let out = artifact::flat_source_output_path(ctx, src);
+                artifact::objcopy_binary(ctx, &intermediates[i], &out)?;
+                outs.push(out);
+            }
+            outs
+        }
+        (false, _) => build_objects_common(assembler, &sources, &obj_dir, ctx, &build_object)?,
+    };
+
+    if is_compile_only(ctx.kind) {
+        return Ok(common::elapsed_secs(start_time));
+    }
+
+    if ctx.kind == "staticlib" {
+        return artifact::archive_static(ctx, &objects, start_time);
+    }
+
+    artifact::link_binary(ctx, &objects, "cc", start_time)
+}
+
+/// Compiles all sources to objects in parallel (non-flat path) and returns object paths.
+fn build_objects_common<F>(
+    assembler: &str,
+    sources: &[String],
+    obj_dir: &Path,
+    ctx: &BuildContext,
+    build_object: &F,
+) -> Result<Vec<String>, String>
+where
+    F: Fn(&str, &str, &str, &BuildContext) -> Result<(), String> + Sync,
+{
+    let objects: Vec<String> = sources
+        .iter()
+        .map(|s| common::object_path(obj_dir, s, "o"))
+        .collect();
+
+    common::parallel_build(
+        sources.len(),
+        |i| build_object(assembler, &sources[i], &objects[i], ctx),
+        ctx.codegen_units,
+    )?;
+
+    Ok(objects)
+}

src/core/build/language/asm/fasm/mod.rs

@@ -0,0 +1,53 @@
+use crate::core::build::builder::BuildContext;
+use crate::core::build::common;
+use crate::core::build::language::asm::common as asm;
+use std::fs;
+use std::path::Path;
+use std::process::Command;
+
+/// Builds an assembly file using the FASM assembler.
+///
+/// Delegates to the shared assembly build logic with FASM configuration.
+pub fn build(ctx: &BuildContext) -> Result<f64, String> {
+    asm::build_assembly(ctx, "FASM", "fasm", &["asm", "fasm"], build_object)
+}
+
+/// Collects all source files for assembly files using FASM.
+pub(crate) fn collect_sources(ctx: &BuildContext) -> Result<Vec<String>, String> {
+    common::collect_sources(
+        ctx.source_roots,
+        &["asm", "fasm"],
+        ctx.exclude_dirs,
+        ctx.include_paths,
+    )
+}
+
+/// Assembles one FASM source into an object file.
+fn build_object(
+    assembler: &str,
+    source: &str,
+    obj_path: &str,
+    ctx: &BuildContext,
+) -> Result<(), String> {
+    if let Some(parent) = Path::new(obj_path).parent() {
+        fs::create_dir_all(parent).map_err(|err| format!("obj dir error: {err}"))?;
+    }
+
+    // Skip rebuilding if the object is up to date
+    if !common::needs_rebuild(source, obj_path) {
+        return Ok(());
+    }
+
+    let mut cmd = Command::new(assembler);
+    cmd.arg(source).arg(obj_path);
+
+    for flag in crate::core::build::language::asm::common::filter_asm_flags(ctx.cflags) {
+        cmd.arg(flag);
+    }
+
+    if ctx.verbose || std::env::var("DCR_DEBUG").is_ok() {
+        eprintln!("[dcr] {:?}", cmd);
+    }
+
+    common::run_command_sync_output(&mut cmd)
+}

src/core/build/language/asm/gas/mod.rs

@@ -0,0 +1,86 @@
+// DCR — Cargo-like C/C++ project manager.
+//
+// Copyright (C) 2026 Dexoron (Bezotechestvo Vladimir) <main@dexoron.su>
+//
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with this program.  If not, see <https://www.gnu.org/licenses/>.
+
+use crate::core::build::builder::BuildContext;
+use crate::core::build::common;
+use crate::core::build::language::asm::common as asm;
+use std::fs;
+use std::path::Path;
+use std::process::Command;
+
+/// Builds GAS (`.s`) sources via the GNU Assembler.
+///
+/// Resolves `as` on PATH and delegates to the shared assembly builder. For
+/// `flat-bin`, intermediates are converted with objcopy after assembly.
+pub fn build(ctx: &BuildContext) -> Result<f64, String> {
+    // Use full path to as
+    let as_path = std::process::Command::new("which")
+        .arg("as")
+        .output()
+        .ok()
+        .and_then(|o| String::from_utf8(o.stdout).ok())
+        .map(|s| s.trim().to_string())
+        .filter(|s| !s.is_empty())
+        .unwrap_or_else(|| "as".to_string());
+    asm::build_assembly_via_objcopy(ctx, "GAS", &as_path, &["s"], build_object)
+}
+
+/// Collects assembly source files with .s extension from the build context's source roots.
+///
+/// Excludes specified directories and respects include paths for filtering.
+pub(crate) fn collect_sources(ctx: &BuildContext) -> Result<Vec<String>, String> {
+    common::collect_sources(
+        ctx.source_roots,
+        &["s"],
+        ctx.exclude_dirs,
+        ctx.include_paths,
+    )
+}
+
+/// Assembles a single .s source file into an object file using the provided assembler.
+///
+/// Creates parent directories for the output object, skips if up-to-date,
+/// runs the assembler with flags from the build context, and handles verbose output.
+fn build_object(
+    assembler: &str,
+    source: &str,
+    obj_path: &str,
+    ctx: &BuildContext,
+) -> Result<(), String> {
+    if let Some(parent) = Path::new(obj_path).parent() {
+        fs::create_dir_all(parent).map_err(|err| format!("obj dir error: {err}"))?;
+    }
+
+    // Check if the object file is already up to date to avoid unnecessary rebuilds.
+    if !common::needs_rebuild(source, obj_path) {
+        return Ok(());
+    }
+
+    // Prepare the assembler command with source file and output path.
+    let mut cmd = Command::new(assembler);
+    cmd.arg(source).arg("-o").arg(obj_path);
+
+    for flag in crate::core::build::language::asm::common::filter_asm_flags(ctx.cflags) {
+        cmd.arg(flag);
+    }
+
+    if ctx.verbose || std::env::var("DCR_DEBUG").is_ok() {
+        eprintln!("[dcr] {:?}", cmd);
+    }
+
+    common::run_command_sync_output(&mut cmd)
+}

src/core/build/language/asm/masm/mod.rs

@@ -0,0 +1,65 @@
+use crate::core::build::builder::BuildContext;
+use crate::core::build::common;
+use crate::core::build::language::asm::common as asm;
+use std::fs;
+use std::path::Path;
+use std::process::Command;
+
+/// Builds MASM (`.asm`) sources via `ml`.
+///
+/// For `flat-bin`, intermediates are converted with objcopy after assembly.
+/// Returns elapsed seconds or an error.
+pub fn build(ctx: &BuildContext) -> Result<f64, String> {
+    asm::build_assembly_via_objcopy(ctx, "MASM", "ml", &["asm"], build_object)
+}
+
+/// Collects MASM assembly source files from the given source roots.
+pub(crate) fn collect_sources(ctx: &BuildContext) -> Result<Vec<String>, String> {
+    common::collect_sources(
+        ctx.source_roots,
+        &["asm"],
+        ctx.exclude_dirs,
+        ctx.include_paths,
+    )
+}
+
+/// Builds a single MASM object file from the given source.
+///
+/// Creates the parent directory for the output object if it doesn't exist,
+/// skips the build if the object is already up to date, constructs the ml
+/// command line with flags, prints the command in debug mode if enabled,
+/// and executes it.
+fn build_object(
+    assembler: &str,
+    source: &str,
+    obj_path: &str,
+    ctx: &BuildContext,
+) -> Result<(), String> {
+    if let Some(parent) = Path::new(obj_path).parent() {
+        // Ensure the parent directory exists for the object file
+        fs::create_dir_all(parent).map_err(|err| format!("obj dir error: {err}"))?;
+    }
+
+    if !common::needs_rebuild(source, obj_path) {
+        // Skip rebuild if the object file is already current
+        return Ok(());
+    }
+
+    let mut cmd = Command::new(assembler);
+    cmd.arg("/nologo")
+        .arg("/c")
+        .arg("/Fo")
+        .arg(obj_path)
+        .arg(source);
+
+    for flag in crate::core::build::language::asm::common::filter_asm_flags(ctx.cflags) {
+        // Add filtered compiler flags to the command
+        cmd.arg(flag);
+    }
+
+    if ctx.verbose || std::env::var("DCR_DEBUG").is_ok() {
+        eprintln!("[dcr] {:?}", cmd);
+    }
+
+    common::run_command_sync_output(&mut cmd)
+}

src/core/build/language/asm/mod.rs

@@ -0,0 +1,45 @@
+// DCR — Cargo-like C/C++ project manager.
+//
+// Copyright (C) 2026 Dexoron (Bezotechestvo Vladimir) <main@dexoron.su>
+//
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with this program.  If not, see <https://www.gnu.org/licenses/>.
+
+/// Assembly language module for the DCR build system.
+pub mod common;
+pub mod fasm;
+pub mod gas;
+pub mod masm;
+pub mod nasm;
+
+use crate::core::build::language::Language;
+
+/// Represents the assembly language support in the build system.
+pub struct Asm;
+
+impl Language for Asm {
+    /// Returns the identifier string for this language.
+    fn id(&self) -> &'static str {
+        "asm"
+    }
+
+    /// Returns the list of supported file extensions for assembly files.
+    fn extensions(&self) -> &'static [&'static str] {
+        &["s", "S", "asm"]
+    }
+
+    /// Checks whether the given token matches the assembly language, using case-insensitive comparison.
+    fn matches_token(&self, token: &str) -> bool {
+        token.eq_ignore_ascii_case("asm")
+    }
+}

src/core/build/language/asm/nasm/mod.rs

@@ -0,0 +1,128 @@
+// DCR — Cargo-like C/C++ project manager.
+//
+// Copyright (C) 2026 Dexoron (Bezotechestvo Vladimir) <main@dexoron.su>
+//
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with this program.  If not, see <https://www.gnu.org/licenses/>.
+
+/// Support for NASM assembly language in the DCR build system.
+use crate::core::build::builder::BuildContext;
+use crate::core::build::common;
+use crate::core::build::language::asm::common as asm;
+use std::fs;
+use std::path::Path;
+use std::process::Command;
+
+/// Builds assembly sources using the NASM assembler.
+///
+/// Delegates to the shared assembly builder with NASM-specific configuration.
+pub fn build(ctx: &BuildContext) -> Result<f64, String> {
+    asm::build_assembly(ctx, "NASM", "nasm", &["asm"], build_object)
+}
+
+/// Collects source files for NASM assembly.
+///
+/// Filters for .asm files only, as NASM uses that extension (distinct from GAS .s).
+pub(crate) fn collect_sources(ctx: &BuildContext) -> Result<Vec<String>, String> {
+    // NASM handles .asm only (not .s which is GAS syntax, not .S which is GCC preprocessed)
+    common::collect_sources(
+        ctx.source_roots,
+        &["asm"],
+        ctx.exclude_dirs,
+        ctx.include_paths,
+    )
+}
+
+/// Builds a single object file from an assembly source using NASM.
+///
+/// Handles directory creation, rebuild checks, format selection, and command execution.
+fn build_object(
+    assembler: &str,
+    source: &str,
+    obj_path: &str,
+    ctx: &BuildContext,
+) -> Result<(), String> {
+    if let Some(parent) = Path::new(obj_path).parent() {
+        // Ensure output directory exists before building.
+        fs::create_dir_all(parent).map_err(|err| format!("obj dir error: {err}"))?;
+    }
+
+    // Skip building if the object is already up to date.
+    if !common::needs_rebuild(source, obj_path) {
+        return Ok(());
+    }
+
+    // Select appropriate object format for the target platform and binary type.
+    let format = if crate::utils::build::is_flat_bin(ctx.kind) {
+        "bin"
+    } else {
+        nasm_format(ctx.platform)
+    };
+
+    let mut cmd = Command::new(assembler);
+    cmd.arg("-f")
+        .arg(format)
+        .arg(source)
+        .arg("-o")
+        .arg(obj_path);
+
+    // Append any additional assembly flags from build context.
+    for flag in crate::core::build::language::asm::common::filter_asm_flags(ctx.cflags) {
+        cmd.arg(flag);
+    }
+
+    if ctx.verbose || std::env::var("DCR_DEBUG").is_ok() {
+        eprintln!("[dcr] {:?}", cmd);
+    }
+
+    common::run_command_sync_output(&mut cmd)
+}
+
+/// Selects the NASM object file format string based on the target platform.
+///
+/// Supports different formats for x86 on various OSes and architectures.
+fn nasm_format(platform: Option<&str>) -> &'static str {
+    if let Some(p) = platform {
+        let p = p.to_lowercase().replace('-', "_");
+        if p == "x86" || (p.starts_with('i') && p.ends_with("86") && p.len() == 4) {
+            #[cfg(target_os = "macos")]
+            {
+                return "macho32";
+            }
+            #[cfg(target_os = "windows")]
+            {
+                return "win32";
+            }
+            #[cfg(not(any(target_os = "macos", target_os = "windows")))]
+            {
+                return "elf32";
+            }
+        }
+    }
+    #[cfg(target_os = "linux")]
+    {
+        "elf64"
+    }
+    #[cfg(target_os = "macos")]
+    {
+        "macho64"
+    }
+    #[cfg(target_os = "windows")]
+    {
+        "win64"
+    }
+    #[cfg(not(any(target_os = "linux", target_os = "macos", target_os = "windows")))]
+    {
+        "elf64"
+    }
+}

src/core/build/language/c/mod.rs

@@ -0,0 +1,38 @@
+// DCR — Cargo-like C/C++ project manager.
+//
+// Copyright (C) 2026 Dexoron (Bezotechestvo Vladimir) <main@dexoron.su>
+//
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with this program.  If not, see <https://www.gnu.org/licenses/>.
+
+use crate::core::build::language::Language;
+
+/// Represents the C programming language support within the DCR build system.
+pub struct C;
+
+impl Language for C {
+    /// Returns the unique identifier for the C language.
+    fn id(&self) -> &'static str {
+        "c"
+    }
+
+    /// Returns an array containing the file extension associated with C source code.
+    fn extensions(&self) -> &'static [&'static str] {
+        &["c"]
+    }
+
+    /// Checks whether the given token matches the C language identifier in a case-insensitive manner.
+    fn matches_token(&self, token: &str) -> bool {
+        token.eq_ignore_ascii_case("c")
+    }
+}

src/core/build/language/cxx/mod.rs

@@ -0,0 +1,40 @@
+// DCR — Cargo-like C/C++ project manager.
+//
+// Copyright (C) 2026 Dexoron (Bezotechestvo Vladimir) <main@dexoron.su>
+//
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with this program.  If not, see <https://www.gnu.org/licenses/>.
+
+/// C++ language support for the DCR build system.
+pub mod qt;
+
+use crate::core::build::language::Language;
+
+pub struct Cxx;
+
+/// C++ language implementation.
+impl Language for Cxx {
+    /// Returns the language ID "cxx".
+    fn id(&self) -> &'static str {
+        "cxx"
+    }
+    /// Returns the extensions for C++ files.
+    fn extensions(&self) -> &'static [&'static str] {
+        &["cpp", "cxx", "cc"]
+    }
+    /// Checks if the token matches C++ language names, ignoring case.
+    fn matches_token(&self, token: &str) -> bool {
+        // Case-insensitive comparison using to_lowercase
+        matches!(token.to_lowercase().as_str(), "c++" | "cpp" | "cxx")
+    }
+}

src/core/build/language/cxx/qt.rs

@@ -0,0 +1,149 @@
+// DCR — Cargo-like C/C++ project manager.
+//
+// Copyright (C) 2026 Dexoron (Bezotechestvo Vladimir) <main@dexoron.su>
+//
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with this program.  If not, see <https://www.gnu.org/licenses/>.
+
+use crate::core::build::builder::BuildContext;
+use crate::core::build::common;
+use crate::utils::build::run_pkg_config;
+use std::fs;
+use std::path::{Path, PathBuf};
+use std::process::Command;
+
+/// Runs uic/rcc/moc on Qt UI, resource, and header sources under `build_dir/qt`.
+///
+/// # Parameters
+/// - `ctx`: Sources, excludes, and toolchain tool paths.
+/// - `build_dir`: Directory that will contain the generated `qt/` tree.
+///
+/// # Returns
+/// - `Ok(Some(qt_dir))` if any generated files were produced.
+/// - `Ok(None)` if there was nothing to process.
+/// - `Err` if a Qt tool fails.
+pub fn process_qt(ctx: &BuildContext, build_dir: &Path) -> Result<Option<PathBuf>, String> {
+    let qt_dir = build_dir.join("qt");
+    fs::create_dir_all(&qt_dir).map_err(|e| format!("Failed to create qt dir: {e}"))?;
+
+    let extensions = vec!["ui", "qrc", "h", "hpp", "hxx"];
+    let files = common::collect_sources(
+        ctx.source_roots,
+        &extensions,
+        ctx.exclude_dirs,
+        ctx.include_paths,
+    )?;
+
+    let mut qt_moc_args = Vec::new();
+    let qt_modules = vec!["Qt6Core", "Qt6Widgets", "Qt6Gui", "Qt6Svg"];
+
+    // Collect -I and -D flags from pkg-config for Qt modules to use in moc invocations
+    for module in qt_modules {
+        if let Ok(cflags) = run_pkg_config(module, "--cflags") {
+            for flag in cflags.split_whitespace() {
+                if flag.starts_with("-I") || flag.starts_with("-D") {
+                    qt_moc_args.push(flag.to_string());
+                }
+            }
+        }
+    }
+
+    let mut generated_any = false;
+
+    for file in files {
+        let path = Path::new(&file);
+        let ext = path.extension().and_then(|e| e.to_str()).unwrap_or("");
+
+        match ext {
+            "ui" => {
+                if let Some(uic) = ctx.uic {
+                    let out_name = path.file_stem().unwrap().to_str().unwrap();
+                    let out_file = qt_dir.join(format!("ui_{out_name}.h"));
+                    run_command(
+                        uic,
+                        &[path.to_str().unwrap(), "-o", out_file.to_str().unwrap()],
+                        ctx.verbose,
+                    )?;
+                    generated_any = true;
+                }
+            }
+            "qrc" => {
+                if let Some(rcc) = ctx.rcc {
+                    let out_name = path.file_stem().unwrap().to_str().unwrap();
+                    let out_file = qt_dir.join(format!("qrc_{out_name}.cpp"));
+                    run_command(
+                        rcc,
+                        &[
+                            path.to_str().unwrap(),
+                            "-name",
+                            out_name,
+                            "-o",
+                            out_file.to_str().unwrap(),
+                        ],
+                        ctx.verbose,
+                    )?;
+                    generated_any = true;
+                }
+            }
+            "h" | "hpp" | "hxx" => {
+                if let Some(moc) = ctx.moc {
+                    let content = fs::read_to_string(path)
+                        .map_err(|e| format!("Failed to read {}: {e}", path.display()))?;
+                    if content.contains("Q_OBJECT") {
+                        let out_name = path.file_stem().unwrap().to_str().unwrap();
+                        let out_file = qt_dir.join(format!("moc_{out_name}.cpp"));
+
+                        let mut moc_args = Vec::new();
+
+                        for arg in &qt_moc_args {
+                            moc_args.push(arg.as_str());
+                        }
+
+                        for inc in ctx.include_paths.iter().chain(ctx.include_dirs.iter()) {
+                            moc_args.push("-I");
+                            moc_args.push(inc);
+                        }
+
+                        moc_args.push(path.to_str().unwrap());
+                        moc_args.push("-o");
+                        moc_args.push(out_file.to_str().unwrap());
+
+                        run_command(moc, &moc_args, ctx.verbose)?;
+                        generated_any = true;
+                    }
+                }
+            }
+            _ => {}
+        }
+    }
+
+    if generated_any {
+        Ok(Some(qt_dir))
+    } else {
+        Ok(None)
+    }
+}
+
+/// Executes the specified command with the given arguments and returns success or an error message.
+fn run_command(cmd_path: &str, args: &[&str], verbose: bool) -> Result<(), String> {
+    let mut cmd = Command::new(cmd_path);
+    cmd.args(args);
+    if verbose || std::env::var("DCR_DEBUG").is_ok() {
+        eprintln!("[dcr] {:?}", cmd);
+    }
+    match cmd.status() {
+        Ok(s) if s.success() => Ok(()),
+        Ok(s) => Err(format!("Command {} failed with status {}", cmd_path, s)),
+        Err(e) => Err(format!("Failed to execute {}: {}", cmd_path, e)),
+    }
+}

src/core/build/language/llvm_ir/mod.rs

@@ -0,0 +1,68 @@
+use crate::core::build::builder::BuildContext;
+use crate::core::build::common;
+use crate::core::build::language::Language;
+use crate::core::build::language::asm::common as asm;
+use std::fs;
+use std::path::Path;
+use std::process::Command;
+
+/// Represents the LLVM IR language implementation for the build system.
+pub struct LlvmIr;
+
+impl Language for LlvmIr {
+    /// Returns the unique identifier for the LLVM IR language.
+    fn id(&self) -> &'static str {
+        "llvm_ir"
+    }
+
+    /// Returns the list of file extensions recognized for this language.
+    fn extensions(&self) -> &'static [&'static str] {
+        &["ll"]
+    }
+
+    /// Determines whether the provided token matches the LLVM IR language.
+    fn matches_token(&self, token: &str) -> bool {
+        matches!(token.to_lowercase().as_str(), "llvm_ir" | "llvm-ir" | "ll")
+    }
+}
+
+/// Builds LLVM IR source files into object files using llc.
+pub fn build(ctx: &BuildContext) -> Result<f64, String> {
+    asm::build_assembly_via_objcopy(ctx, "LLVM-IR", "llc", &["ll"], build_object)
+}
+
+/// Collects source files for LLVM IR compilation from the given context.
+pub(crate) fn collect_sources(ctx: &BuildContext) -> Result<Vec<String>, String> {
+    common::collect_sources(
+        ctx.source_roots,
+        &["ll"],
+        ctx.exclude_dirs,
+        ctx.include_paths,
+    )
+}
+
+/// Builds a single LLVM IR source file into an object file.
+fn build_object(
+    assembler: &str,
+    source: &str,
+    obj_path: &str,
+    ctx: &BuildContext,
+) -> Result<(), String> {
+    if let Some(parent) = Path::new(obj_path).parent() {
+        // Create parent directory if it does not exist
+        fs::create_dir_all(parent).map_err(|err| format!("obj dir error: {err}"))?;
+    }
+
+    if !common::needs_rebuild(source, obj_path) {
+        return Ok(());
+    }
+
+    let mut cmd = Command::new(assembler);
+    cmd.arg("-filetype=obj").arg(source).arg("-o").arg(obj_path);
+
+    for flag in ctx.cflags {
+        cmd.arg(flag);
+    }
+
+    common::run_command_sync_output(&mut cmd)
+}

src/core/build/language/mod.rs

@@ -0,0 +1,67 @@
+// DCR — Cargo-like C/C++ project manager.
+//
+// Copyright (C) 2026 Dexoron (Bezotechestvo Vladimir) <main@dexoron.su>
+//
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with this program.  If not, see <https://www.gnu.org/licenses/>.
+
+/// Core module for language support in the DCR build system.
+/// Defines the Language trait and helper functions to register and lookup languages.
+pub mod asm;
+pub mod c;
+pub mod cxx;
+pub mod llvm_ir;
+
+/// Trait representing a supported programming language.
+/// Each implementation must specify its unique identifier, list of supported file extensions,
+/// and a method to determine if a given token matches the language.
+pub trait Language {
+    fn id(&self) -> &'static str;
+    fn extensions(&self) -> &'static [&'static str];
+    fn matches_token(&self, token: &str) -> bool;
+}
+
+/// Returns a fixed-size array containing static references to all supported language types.
+pub fn languages() -> [&'static dyn Language; 4] {
+    [&c::C, &cxx::Cxx, &asm::Asm, &llvm_ir::LlvmIr]
+}
+
+/// Looks up the language implementation that matches the given token by checking each language's
+/// matches_token method. Returns the first match or None if no language matches.
+pub fn language_for_token(token: &str) -> Option<&'static dyn Language> {
+    languages().into_iter().find(|l| l.matches_token(token))
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    /// Ensures that input tokens are resolved to the correct language IDs.
+    #[test]
+    fn tokens_resolve_to_languages() {
+        assert_eq!(language_for_token("c").unwrap().id(), "c");
+        assert_eq!(language_for_token("c++").unwrap().id(), "cxx");
+        assert_eq!(language_for_token("cpp").unwrap().id(), "cxx");
+        assert_eq!(language_for_token("cxx").unwrap().id(), "cxx");
+        assert_eq!(language_for_token("asm").unwrap().id(), "asm");
+        assert!(language_for_token("rust").is_none());
+    }
+
+    /// Ensures that each language reports the expected set of file extensions.
+    #[test]
+    fn languages_expose_expected_extensions() {
+        assert_eq!(c::C.extensions(), &["c"]);
+        assert_eq!(cxx::Cxx.extensions(), &["cpp", "cxx", "cc"]);
+        assert_eq!(asm::Asm.extensions(), &["s", "S", "asm"]);
+    }
+}

src/core/build/mod.rs

@@ -0,0 +1,34 @@
+// DCR — Cargo-like C/C++ project manager.
+//
+// Copyright (C) 2026 Dexoron (Bezotechestvo Vladimir) <main@dexoron.su>
+//
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with this program.  If not, see <https://www.gnu.org/licenses/>.
+
+/// Core build module for DCR — a Cargo-like C/C++ project manager.
+/// This module defines the build engine and re-exports key components for
+/// building C/C++ projects.
+#[cfg(feature = "archive")]
+pub mod archive;
+pub mod builder;
+pub mod cache;
+pub mod common;
+pub mod engine;
+pub mod language;
+pub mod report;
+pub mod resolve;
+pub mod steps;
+
+pub use engine::run_build;
+pub use report::{BuildEvent, BuildReporter, BuildRequest};
+pub use resolve::get_build_string_with_profile;

src/core/build/report.rs

@@ -0,0 +1,93 @@
+// DCR — Cargo-like C/C++ project manager.
+//
+// Copyright (C) 2026 Dexoron (Bezotechestvo Vladimir) <main@dexoron.su>
+//
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with this program.  If not, see <https://www.gnu.org/licenses/>.
+
+// The reporter decouples the build engine from any particular frontend: the CLI
+// renders events as coloured lines, a TUI/GUI would push them into a widget and
+// MCP would serialise them to JSON. The engine only ever calls `on_event`.
+
+use std::sync::{Arc, atomic::AtomicBool};
+
+/// Represents a build request with options for the build process, including profile selection, target specification, force flag, verbosity, workspace, and a cancellation signal.
+pub struct BuildRequest {
+    pub profile: String,
+    pub target: Option<String>,
+    pub force: bool,
+    pub verbose: bool,
+    pub workspace: Option<String>,
+    pub cancel: Arc<AtomicBool>,
+}
+
+/// Contains the result of a build operation, specifically the duration in seconds.
+#[allow(dead_code)]
+pub struct BuildOutcome {
+    pub secs: f64,
+}
+
+/// Wraps a string message as a build error.
+pub struct BuildError {
+    pub message: String,
+}
+
+/// Creates a BuildError from a String message.
+impl From<String> for BuildError {
+    fn from(message: String) -> Self {
+        BuildError { message }
+    }
+}
+
+/// Represents events that the build engine can emit during compilation and packaging.
+pub enum BuildEvent<'a> {
+    TargetStart {
+        index: usize,
+        total: usize,
+        target: &'a str,
+    },
+    ProjectStart {
+        name: &'a str,
+        profile: &'a str,
+        target: &'a str,
+    },
+    DepBuilding {
+        name: &'a str,
+        version: &'a str,
+    },
+    DepReady {
+        name: &'a str,
+        version: &'a str,
+        rebuilt: bool,
+    },
+    Compiling {
+        name: &'a str,
+        version: &'a str,
+    },
+    Packing {
+        path: &'a str,
+    },
+    CompilerOutput {
+        stream: &'a str,
+        text: &'a str,
+    },
+    Finished {
+        secs: f64,
+    },
+}
+
+/// Trait for handling build events in different reporting backends.
+pub trait BuildReporter {
+    /// Callback invoked when a build event is generated.
+    fn on_event(&mut self, event: BuildEvent<'_>);
+}