Merge pull request #8 from babichgh/master

Update user input prompts to read from /dev/tty

.github/ISSUE_TEMPLATE/bug_report.md

@@ -0,0 +1,51 @@
+---
+name: Bug Report
+about: Something is broken or behaves unexpectedly
+title: "[bug] "
+labels: bug
+assignees: ''
+---
+
+## Description
+
+<!-- A clear and concise description of the bug -->
+
+## Steps to Reproduce
+
+1. 
+2. 
+3. 
+
+## Expected Behavior
+
+<!-- What should have happened -->
+
+## Actual Behavior
+
+<!-- What actually happened, include full error output -->
+
+```
+paste error output here
+```
+
+## Environment
+
+- **DCR version** (`dcr --version`): 
+- **OS**: 
+- **Compiler / toolchain** (`gcc --version` or `clang --version`): 
+
+## Minimal Reproducible Project
+
+<!-- If possible, share a minimal dcr.toml + source that reproduces the issue -->
+
+```toml
+# dcr.toml
+```
+
+```c
+// src/main.c
+```
+
+## Additional Context
+
+<!-- Anything else that might help -->

.github/ISSUE_TEMPLATE/feature_request.md

@@ -0,0 +1,35 @@
+---
+name: Feature Request
+about: Suggest an idea or improvement
+title: "[feat] "
+labels: enhancement
+assignees: ''
+---
+
+## Problem / Motivation
+
+<!-- What problem does this solve? What are you trying to do that's currently hard or impossible? -->
+
+## Proposed Solution
+
+<!-- Describe what you want. Be as specific as possible — CLI flags, config syntax, behavior -->
+
+## Example
+
+<!-- Show how it would look in practice (command, dcr.toml snippet, output) -->
+
+```sh
+# example command
+```
+
+```toml
+# example config
+```
+
+## Alternatives Considered
+
+<!-- Have you tried workarounds? Are there other ways to solve this? -->
+
+## Additional Context
+
+<!-- Links, prior art, related issues, etc. -->

.github/workflows/aur.yml

@@ -1,138 +0,0 @@
-name: AUR Publish
-
-on:
-  workflow_dispatch:
-    inputs:
-      version:
-        description: "Tag version without v prefix (e.g. 0.2.2)"
-        required: true
-  push:
-    tags:
-      - "v*"
-
-permissions:
-  contents: read
-
-jobs:
-  publish-aur:
-    # Не публикуем dev/pre-release теги в AUR
-    if: "!contains(github.ref_name, '-')"
-    runs-on: ubuntu-latest
-    environment: aur
-    steps:
-      - name: Checkout
-        uses: actions/checkout@v4
-
-      - name: Derive version and checksum
-        id: meta
-        shell: bash
-        run: |
-          set -euo pipefail
-          if [[ "${GITHUB_EVENT_NAME}" == "workflow_dispatch" ]]; then
-            PKGVER="${{ inputs.version }}"
-          else
-            PKGVER="${GITHUB_REF_NAME#v}"
-          fi
-          SRC_URL="https://github.com/dexoron/dcr/archive/refs/tags/v${PKGVER}.tar.gz"
-          SHA256="$(curl -fsSL "$SRC_URL" | sha256sum | awk '{print $1}')"
-
-          echo "pkgver=$PKGVER" >> "$GITHUB_OUTPUT"
-          echo "source_url=$SRC_URL" >> "$GITHUB_OUTPUT"
-          echo "sha256=$SHA256" >> "$GITHUB_OUTPUT"
-
-      - name: Render AUR metadata
-        shell: bash
-        run: |
-          set -euo pipefail
-          PKGVER='${{ steps.meta.outputs.pkgver }}'
-          SRC_URL='${{ steps.meta.outputs.source_url }}'
-          SHA256='${{ steps.meta.outputs.sha256 }}'
-
-          cat > packaging/aur/dcr/PKGBUILD <<PKG
-          pkgname=dcr
-          pkgver=${PKGVER}
-          pkgrel=1
-          pkgdesc="Cargo-like utility to manage C/C++ projects"
-          arch=('x86_64' 'aarch64')
-          url="https://github.com/dexoron/dcr"
-          license=('MIT')
-          depends=('gcc-libs')
-          makedepends=('cargo')
-          options=('!lto')
-          optdepends=(
-            'gcc: build C/C++ projects with GCC'
-            'clang: build C/C++ projects with Clang'
-          )
-          source=("\$pkgname-\$pkgver.tar.gz::\$url/archive/refs/tags/v\$pkgver.tar.gz")
-          sha256sums=('${SHA256}')
-
-          build() {
-            cd "\$srcdir/\$pkgname-\$pkgver"
-            export CARGO_PROFILE_RELEASE_LTO=false
-            export RUSTFLAGS="\${RUSTFLAGS:-}"
-            export RUSTFLAGS="\${RUSTFLAGS/-C link-arg=-fuse-ld=lld/}"
-            cargo build --release --locked
-          }
-
-          package() {
-            cd "\$srcdir/\$pkgname-\$pkgver"
-            install -Dm755 "target/release/dcr" "\$pkgdir/usr/bin/dcr"
-            install -Dm644 LICENSE "\$pkgdir/usr/share/licenses/\$pkgname/LICENSE"
-          }
-          PKG
-
-          cat > packaging/aur/dcr/.SRCINFO <<SRC
-          pkgbase = dcr
-          	pkgdesc = Cargo-like utility to manage C/C++ projects
-          	pkgver = ${PKGVER}
-          	pkgrel = 1
-          	url = https://github.com/dexoron/dcr
-          	arch = x86_64
-          	arch = aarch64
-          	license = MIT
-          	makedepends = cargo
-          	depends = gcc-libs
-          	optdepends = gcc: build C/C++ projects with GCC
-          	optdepends = clang: build C/C++ projects with Clang
-            options = !lto
-          	source = dcr-${PKGVER}.tar.gz::${SRC_URL}
-          	sha256sums = ${SHA256}
-
-          pkgname = dcr
-          SRC
-
-      - name: Push to AUR
-        env:
-          AUR_SSH_PRIVATE_KEY: ${{ secrets.AUR_SSH_PRIVATE_KEY }}
-          AUR_PACKAGE: dcr
-        shell: bash
-        run: |
-          set -euo pipefail
-
-          if [[ -z "${AUR_SSH_PRIVATE_KEY:-}" ]]; then
-            echo "AUR_SSH_PRIVATE_KEY secret is missing"
-            exit 1
-          fi
-
-          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'
-          git clone "ssh://aur@aur.archlinux.org/${AUR_PACKAGE}.git" aur-repo
-          cp packaging/aur/dcr/PKGBUILD aur-repo/PKGBUILD
-          cp packaging/aur/dcr/.SRCINFO aur-repo/.SRCINFO
-
-          cd aur-repo
-          git config user.name "github-actions[bot]"
-          git config user.email "github-actions[bot]@users.noreply.github.com"
-
-          if git diff --quiet; then
-            echo "No AUR changes"
-            exit 0
-          fi
-
-          git add PKGBUILD .SRCINFO
-          git commit -m "dcr ${{ steps.meta.outputs.pkgver }}"
-          git push

.github/workflows/dexoron-packages-index.yml

@@ -0,0 +1,109 @@
+name: Dexoron Packages Index
+
+on:
+  workflow_dispatch:
+    inputs:
+      tag:
+        description: "Версия (тег) для ручного импорта пакетов (например, v0.6.9)"
+        required: true
+        type: string
+  workflow_run:
+    workflows: ["Release"]
+    types:
+      - completed
+
+permissions:
+  contents: read
+
+jobs:
+  update-packages-index:
+    runs-on: ubuntu-latest
+    if: ${{ github.event_name == 'workflow_dispatch' || github.event_workflow_run.conclusion == 'success' }}
+
+    steps:
+      - name: Checkout Central Packages Repo
+        uses: actions/checkout@v4
+        with:
+          repository: 'dexoron/packages'
+          token: ${{ secrets.PACKAGES_REPO_TOKEN }}
+          path: 'central-packages'
+
+      - name: Import GPG Key
+        uses: crazy-max/ghaction-import-gpg@v6
+        with:
+          gpg_private_key: ${{ secrets.GPG_PRIVATE_KEY }}
+
+      # --- Загрузка артефактов (сохранена прежняя логика) ---
+      - name: Download Artifacts
+        if: ${{ github.event_name == 'workflow_run' }}
+        uses: actions/download-artifact@v4
+        with:
+          path: central-packages/
+          github-token: ${{ secrets.GITHUB_TOKEN }}
+          run-id: ${{ github.event.workflow_run.id }}
+
+      - name: Download Packages from Release Assets
+        if: ${{ github.event_name == 'workflow_dispatch' }}
+        env:
+          GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+          TAG: ${{ inputs.tag }}
+        run: |
+          gh release download "$TAG" --repo dexoron/dcr --pattern "*.pkg.tar.zst" --dir central-packages/archlinux/x86_64/ --clobber
+          gh release download "$TAG" --repo dexoron/dcr --pattern "*.deb" --dir central-packages/debian/ --clobber
+          gh release download "$TAG" --repo dexoron/dcr --pattern "*.rpm" --dir central-packages/fedora/x86_64/ --clobber
+
+      # --- ИНДЕКСАЦИЯ И ПОДПИСЬ ---
+
+      - name: Update Pacman Database
+        run: |
+          docker run --rm \
+            -v ${{ github.workspace }}/central-packages:/packages \
+            -v ~/.gnupg:/root/.gnupg \
+            archlinux:latest \
+            bash -c '
+              cd /packages/archlinux/x86_64 && \
+              packages=(*.pkg.tar.zst) && \
+              repo-add --sign dexoron.db.tar.gz "${packages[@]}" && \
+              ln -sf dexoron.db.tar.gz dexoron.db && \
+              ln -sf dexoron.files.tar.gz dexoron.files
+            '
+      - name: Fix GPG permissions after Docker
+        run: sudo chown -R runner:runner ~/.gnupg
+
+      - name: Update Debian APT Repository Index
+        run: |
+          sudo apt-get update && sudo apt-get install -y dpkg-dev
+          cd central-packages/debian
+          dpkg-scanpackages . /dev/null | gzip -9c > Packages.gz
+          
+          echo "Origin: Dexoron Packages" > Release
+          echo "Label: Dexoron Packages" >> Release
+          echo "Suite: stable" >> Release
+          echo "Codename: stable" >> Release
+          echo "Architectures: amd64" >> Release
+          echo "Components: main" >> Release
+          echo "Description: Dexoron binary package repository" >> Release
+          echo "Date: $(date -uR)" >> Release
+          echo "SHA256:" >> Release
+          echo " $(sha256sum Packages.gz | awk '{print $1" "$2}')" >> Release
+          
+          gpg --batch --yes --pinentry-mode loopback --local-user 74322D39483E9C9E8C86C0AA0770A5C2A2A82DAC --detach-sign --armor --output Release.gpg Release
+          gpg --batch --yes --pinentry-mode loopback --local-user 74322D39483E9C9E8C86C0AA0770A5C2A2A82DAC --clearsign --output InRelease Release
+
+      - name: Update Fedora DNF Repository Index
+        run: |
+          sudo apt-get update && sudo apt-get install -y createrepo-c
+          cd central-packages/fedora/x86_64
+          createrepo_c .
+          gpg --batch --yes --detach-sign --armor --output repodata/repomd.xml.asc repodata/repomd.xml
+
+      - name: Push to dexoron/packages
+        run: |
+          cd central-packages
+          git config user.name "github-actions[bot]"
+          git config user.email "41898282+github-actions[bot]@users.noreply.github.com"
+          git add .
+          if ! git diff --cached --quiet; then
+            git commit -m "chore: update and sign repositories"
+            git push
+          fi

.github/workflows/release.yml

@@ -7,32 +7,81 @@ on:
   workflow_dispatch:
     inputs:
       tag:
-        description: "Tag to build and upload assets for (e.g. v0.6.5)"
+        description: "Tag to build (e.g. v0.6.7)"
         required: true
+      run_linux:
+        description: "Build Linux"
+        type: boolean
+        default: true
+      run_linux_packages:
+        description: "Build Linux Packages (.deb, .rpm, .snap, .pkg.tar.zst)"
+        type: boolean
+        default: true
+      run_aur:
+        description: "Update AUR packages (dcr & dcr-bin)"
+        type: boolean
+        default: false 
+      run_bsd:
+        description: "Build BSD"
+        type: boolean
+        default: true
+      run_macos:
+        description: "Build macOS"
+        type: boolean
+        default: true
+      run_windows:
+        description: "Build Windows"
+        type: boolean
+        default: true
+      run_publish:
+        description: "Publish to crates.io"
+        type: boolean
+        default: false
+      run_brew:
+        description: "Update Homebrew tap"
+        type: boolean
+        default: false
 
 permissions:
   contents: write
 
 jobs:
+  # ── Resolve Tag ────────────────────────────────────────────────────────────
+  setup:
+    runs-on: ubuntu-latest
+    outputs:
+      tag: ${{ steps.tag.outputs.value }}
+      version: ${{ steps.tag.outputs.version }}
+      prerelease: ${{ steps.tag.outputs.prerelease }}
+    steps:
+      - name: Resolve tag
+        id: tag
+        run: |
+          if [[ "${{ github.event_name }}" == "workflow_dispatch" ]]; then
+            TAG="${{ github.event.inputs.tag }}"
+          else
+            TAG="${GITHUB_REF_NAME}"
+          fi
+          VERSION="${TAG#v}"
+          [[ "$TAG" == *"-"* ]] && PRERELEASE="true" || PRERELEASE="false"
+          echo "value=${TAG}"             >> "$GITHUB_OUTPUT"
+          echo "version=${VERSION}"       >> "$GITHUB_OUTPUT"
+          echo "prerelease=${PRERELEASE}" >> "$GITHUB_OUTPUT"
+
+  # ── Release Notes ──────────────────────────────────────────────────────────
   notes:
+    needs: setup
     runs-on: ubuntu-latest
     steps:
       - uses: actions/checkout@v4
         with:
-          # При ручном запуске чекаутим нужный тег
-          ref: ${{ github.event.inputs.tag || github.ref }}
+          ref: ${{ needs.setup.outputs.tag }}
 
       - name: Prepare Release Notes
         shell: bash
         run: |
           set -euo pipefail
-          # При ручном запуске берём версию из инпута, иначе из тега
-          if [[ "${{ github.event_name }}" == "workflow_dispatch" ]]; then
-            tag="${{ github.event.inputs.tag }}"
-            tag="${tag#v}"
-          else
-            tag="${GITHUB_REF_NAME#v}"
-          fi
+          tag="${{ needs.setup.outputs.version }}"
           notes_file=".github/release-notes.md"
           if grep -q "^## \\[${tag}\\]" CHANGELOG.md; then
             awk -v ver="$tag" '
@@ -51,60 +100,23 @@ jobs:
           name: release-notes
           path: .github/release-notes.md
 
-  build:
+  # ── Linux Binaries Matrix ──────────────────────────────────────────────────
+  build-linux:
+    if: ${{ github.event_name == 'push' || github.event.inputs.run_linux == 'true' }}
+    needs: [setup, notes]
+    runs-on: ubuntu-latest
     strategy:
       fail-fast: false
       matrix:
         include:
-          # ── Linux GNU ──────────────────────────────────────────────────────
-          - os: ubuntu-latest
-            target: x86_64-unknown-linux-gnu
-
-          - os: ubuntu-latest
-            target: aarch64-unknown-linux-gnu
-            apt: gcc-aarch64-linux-gnu g++-aarch64-linux-gnu
-            env_cc: CC_aarch64_unknown_linux_gnu=aarch64-linux-gnu-gcc
-            env_linker: CARGO_TARGET_AARCH64_UNKNOWN_LINUX_GNU_LINKER=aarch64-linux-gnu-gcc
-
-          # ── Linux Musl ─────────────────────────────────────────────────────
-          - os: ubuntu-latest
-            target: x86_64-unknown-linux-musl
-            apt: musl-tools
-            env_cc: CC_x86_64_unknown_linux_musl=musl-gcc
-            env_linker: CARGO_TARGET_X86_64_UNKNOWN_LINUX_MUSL_LINKER=musl-gcc
-
-          - os: ubuntu-latest
-            target: aarch64-unknown-linux-musl
-            musl_cross: aarch64-linux-musl-cross
-            env_cc: CC_aarch64_unknown_linux_musl=aarch64-linux-musl-gcc
-            env_linker: CARGO_TARGET_AARCH64_UNKNOWN_LINUX_MUSL_LINKER=aarch64-linux-musl-gcc
-
-          # ── macOS ──────────────────────────────────────────────────────────
-          - os: macos-15-intel
-            target: x86_64-apple-darwin
-
-          - os: macos-latest
-            target: aarch64-apple-darwin
-
-          # ── Windows MSVC ───────────────────────────────────────────────────
-          - os: windows-latest
-            target: x86_64-pc-windows-msvc
-
-          - os: windows-latest
-            target: aarch64-pc-windows-msvc
-
-          # ── Windows GNU ────────────────────────────────────────────────────
-          - os: windows-latest
-            target: x86_64-pc-windows-gnu
-
-          # gnullvm исключён: LLVM MinGW не предустановлен на GitHub Actions
-
-    runs-on: ${{ matrix.os }}
-    needs: notes
+          - target: x86_64-unknown-linux-gnu
+          - target: aarch64-unknown-linux-gnu
+          - target: x86_64-unknown-linux-musl
+          - target: aarch64-unknown-linux-musl
     steps:
       - uses: actions/checkout@v4
         with:
-          ref: ${{ github.event.inputs.tag || github.ref }}
+          ref: ${{ needs.setup.outputs.tag }}
 
       - name: Download Release Notes
         uses: actions/download-artifact@v4
@@ -112,34 +124,10 @@ jobs:
           name: release-notes
           path: .github
 
-      - name: Install apt packages
-        if: runner.os == 'Linux' && matrix.apt != ''
+      - name: Install cargo-zigbuild
         run: |
-          sudo apt-get update
-          sudo apt-get install -y gcc-aarch64-linux-gnu g++-aarch64-linux-gnu musl-tools
-          case "${{ matrix.target }}" in
-            aarch64-unknown-linux-gnu)
-              echo "CC_aarch64-unknown-linux-gnu=aarch64-linux-gnu-gcc" >> $GITHUB_ENV
-              echo "AR_aarch64-unknown-linux-gnu=aarch64-linux-gnu-ar" >> $GITHUB_ENV
-              ;;
-            x86_64-unknown-linux-musl)
-              echo "CC_x86_64-unknown-linux-musl=x86_64-linux-musl-gcc" >> $GITHUB_ENV
-              ;;
-            aarch64-unknown-linux-musl)
-              curl -L https://musl.cc/aarch64-linux-musl-cross.tgz -o /tmp/musl-aarch64.tgz
-              sudo tar xzf /tmp/musl-aarch64.tgz -C /opt
-              echo "/opt/aarch64-linux-musl-cross/bin" >> $GITHUB_PATH
-              echo "CC_aarch64-unknown-linux-musl=aarch64-linux-musl-gcc" >> $GITHUB_ENV
-              echo "AR_aarch64-unknown-linux-musl=aarch64-linux-musl-ar" >> $GITHUB_ENV
-              ;;
-          esac
-
-      - name: Setup LLVM + MinGW (gnullvm)
-        if: contains(matrix.target, 'gnullvm')
-        shell: pwsh
-        run: |
-          choco install llvm mingw -y --no-progress
-          echo "C:\Program Files\LLVM\bin" | Out-File -FilePath $env:GITHUB_PATH -Encoding utf8 -Append
+          pip install cargo-zigbuild
+          echo "$HOME/.local/bin" >> $GITHUB_PATH
 
       - name: Setup Rust
         uses: dtolnay/rust-toolchain@stable
@@ -147,56 +135,653 @@ jobs:
           targets: ${{ matrix.target }}
 
       - name: Build
-        shell: bash
-        env:
-          MATRIX_ENV_CC: ${{ matrix.env_cc }}
-          MATRIX_ENV_LINKER: ${{ matrix.env_linker }}
         run: |
-          if [[ -n "${MATRIX_ENV_CC:-}" ]]; then
-            export "${MATRIX_ENV_CC?}"
-          fi
-          if [[ -n "${MATRIX_ENV_LINKER:-}" ]]; then
-            export "${MATRIX_ENV_LINKER?}"
-          fi
-          cargo build --release --target ${{ matrix.target }}
-
-      - name: Derive version string
-        shell: bash
-        run: |
-          if [[ "${{ github.event_name }}" == "workflow_dispatch" ]]; then
-            RAW_TAG="${{ github.event.inputs.tag }}"
+          if [ "${{ matrix.target }}" != "x86_64-unknown-linux-gnu" ]; then
+            cargo zigbuild --release --target ${{ matrix.target }}
           else
-            RAW_TAG="${GITHUB_REF_NAME}"
+            cargo build --release --target ${{ matrix.target }}
           fi
-          echo "RELEASE_TAG=${RAW_TAG}" >> "$GITHUB_ENV"
-          echo "RELEASE_VERSION=${RAW_TAG#v}" >> "$GITHUB_ENV"
 
-      - name: Derive asset name (Unix)
-        if: runner.os != 'Windows'
-        shell: bash
+      - name: Prepare Artifact
         run: |
-          echo "ASSET_NAME=dcr-${{ matrix.target }}-${RELEASE_VERSION}" >> "$GITHUB_ENV"
-
-      - name: Derive asset name (Windows)
-        if: runner.os == 'Windows'
-        shell: pwsh
-        run: |
-          "ASSET_NAME=dcr-${{ matrix.target }}-$($env:RELEASE_VERSION).exe" >> $env:GITHUB_ENV
-
-      - name: Prepare Artifact (Unix)
-        if: runner.os != 'Windows'
-        shell: bash
-        run: cp target/${{ matrix.target }}/release/dcr "$ASSET_NAME"
-
-      - name: Prepare Artifact (Windows)
-        if: runner.os == 'Windows'
-        shell: pwsh
-        run: Copy-Item "target/${{ matrix.target }}/release/dcr.exe" "$env:ASSET_NAME"
+          ASSET="dcr-${{ matrix.target }}-${{ needs.setup.outputs.version }}"
+          cp target/${{ matrix.target }}/release/dcr "$ASSET"
+          echo "ASSET_NAME=${ASSET}" >> "$GITHUB_ENV"
 
       - name: Upload Release Asset
         uses: softprops/action-gh-release@v2
         with:
-          tag_name: ${{ env.RELEASE_TAG }}
+          tag_name: ${{ needs.setup.outputs.tag }}
           files: ${{ env.ASSET_NAME }}
           body_path: .github/release-notes.md
-          prerelease: ${{ contains(env.RELEASE_TAG, '-') }}
+          prerelease: ${{ needs.setup.outputs.prerelease == 'true' }}
+
+  # ── Linux Packages Matrix (.deb, .rpm, .pkg.tar.zst, .snap) ────────────────
+  build-linux-packages:
+    if: ${{ github.event_name == 'push' || github.event.inputs.run_linux_packages == 'true' }}
+    needs: [setup, notes]
+    runs-on: ubuntu-latest
+    strategy:
+      fail-fast: false
+      matrix:
+        include:
+          - package_type: deb
+            artifact_name: debian-package
+          - package_type: rpm
+            artifact_name: rpm-package
+          - package_type: arch
+            artifact_name: arch-package
+          - package_type: snap
+            artifact_name: snap-package
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          ref: ${{ needs.setup.outputs.tag }}
+
+      - name: Setup Rust (For non-container builds)
+        if: matrix.package_type != 'arch'
+        uses: dtolnay/rust-toolchain@stable
+
+      # ── DEB Build ──
+      - name: Build Debian Package
+        if: matrix.package_type == 'deb'
+        run: |
+          cargo install cargo-deb
+          cargo build --release
+          cargo deb --no-build
+          mkdir -p dist-packages && cp 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
+          cargo generate-rpm
+          mkdir -p dist-packages && cp target/generate-rpm/*.rpm dist-packages/
+
+      # ── Snap Build ──
+      - name: Build Snap Package
+        if: matrix.package_type == 'snap'
+        run: |
+          cargo build --release
+          mkdir -p packaging/snap/dist/bin
+          cp target/release/dcr packaging/snap/dist/bin/
+
+      - name: Snapcraft Build Action
+        if: matrix.package_type == 'snap'
+        uses: snapcore/action-build@v1
+        with:
+          path: packaging/snap
+
+      - name: Prepare Snap Output
+        if: matrix.package_type == 'snap'
+        run: mkdir -p dist-packages && cp packaging/snap/*.snap dist-packages/
+
+      # ── Arch Linux Native Build ──
+      - name: Build Arch Package inside Container
+        if: matrix.package_type == 'arch'
+        run: |
+          PKGVER='${{ needs.setup.outputs.version }}'
+          TAG='${{ needs.setup.outputs.tag }}'
+          SRC_URL="https://github.com/dexoron/dcr/archive/refs/tags/${TAG}.tar.gz"
+          SHA256="$(curl -fsSL "$SRC_URL" | sha256sum | awk '{print $1}')"
+          mkdir -p arch-build
+          cat > arch-build/PKGBUILD <<PKG
+          pkgname=dcr
+          pkgver=${PKGVER}
+          pkgrel=1
+          pkgdesc="Cargo-like utility to manage C/C++ projects"
+          arch=('x86_64')
+          url="https://github.com/dexoron/dcr"
+          license=('GPL-3.0-or-later')
+          depends=('gcc-libs')
+          makedepends=('cargo')
+          options=('!lto')
+          source=("\$pkgname-\$pkgver.tar.gz::\$url/archive/refs/tags/v\$pkgver.tar.gz")
+          sha256sums=('${SHA256}')
+          build() {
+            cd "\$srcdir/\$pkgname-\$pkgver"
+            cargo build --release --locked
+          }
+          package() {
+            cd "\$srcdir/\$pkgname-\$pkgver"
+            install -Dm755 "target/release/dcr" "\$pkgdir/usr/bin/dcr"
+            install -Dm644 LICENSE "\$pkgdir/usr/share/licenses/\$pkgname/LICENSE"
+          }
+          PKG
+          docker run --rm \
+            -v ${{ github.workspace }}/arch-build:/build \
+            archlinux:latest \
+            bash -c "
+              pacman -Syu --noconfirm base-devel cargo gcc-libs git && \
+              useradd -m builduser && \
+              echo 'builduser ALL=(ALL) NOPASSWD: ALL' >> /etc/sudoers && \
+              chown -R builduser:builduser /build && \
+              cd /build && \
+              su builduser -c 'makepkg -s --noconfirm'
+            "
+          mkdir -p dist-packages && cp arch-build/*.pkg.tar.zst dist-packages/
+
+      # ── Upload Artifacts ──
+      - name: Upload Package Artifact
+        uses: actions/upload-artifact@v4
+        with:
+          name: ${{ matrix.artifact_name }}
+          path: dist-packages/*
+          if-no-files-found: ignore
+
+  # ── Publish Packages to Release (Out of Matrix) ────────────────────────────
+  publish-dexoron-packages:
+    needs: [setup, notes, build-linux-packages]
+    runs-on: ubuntu-latest
+    steps:
+      - name: Download Release Notes
+        uses: actions/download-artifact@v4
+        with:
+          name: release-notes
+          path: .github
+
+      - name: Download Built Packages
+        uses: actions/download-artifact@v4
+        with:
+          path: collected-packages
+
+      - name: Upload Everything to GitHub Release
+        uses: softprops/action-gh-release@v2
+        with:
+          tag_name: ${{ needs.setup.outputs.tag }}
+          files: |
+            collected-packages/debian-package/*
+            collected-packages/rpm-package/*
+            collected-packages/arch-package/*
+            collected-packages/snap-package/*
+          body_path: .github/release-notes.md
+          prerelease: ${{ needs.setup.outputs.prerelease == 'true' }}
+
+  # ── macOS Matrix ───────────────────────────────────────────────────────────
+  build-macos:
+    if: ${{ github.event_name == 'push' || github.event.inputs.run_macos == 'true' }}
+    needs: [setup, notes]
+    strategy:
+      fail-fast: false
+      matrix:
+        include:
+          - os: macos-15-intel
+            target: x86_64-apple-darwin
+          - os: macos-latest
+            target: aarch64-apple-darwin
+    runs-on: ${{ matrix.os }}
+    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: Setup Rust
+        uses: dtolnay/rust-toolchain@stable
+        with:
+          targets: ${{ matrix.target }}
+
+      - name: Build
+        run: cargo build --release --target ${{ matrix.target }}
+
+      - name: Prepare Artifact
+        run: |
+          ASSET="dcr-${{ matrix.target }}-${{ needs.setup.outputs.version }}"
+          cp target/${{ matrix.target }}/release/dcr "$ASSET"
+          echo "ASSET_NAME=${ASSET}" >> "$GITHUB_ENV"
+
+      - name: Upload Release Asset
+        uses: softprops/action-gh-release@v2
+        with:
+          tag_name: ${{ needs.setup.outputs.tag }}
+          files: ${{ env.ASSET_NAME }}
+          body_path: .github/release-notes.md
+          prerelease: ${{ needs.setup.outputs.prerelease == 'true' }}
+
+  # ── BSD Systems Matrix ─────────────────────────────────────────────────────
+  build-bsd:
+    if: ${{ github.event_name == 'push' || github.event.inputs.run_bsd == 'true' }}
+    needs: [setup, notes]
+    runs-on: ubuntu-latest
+    strategy:
+      fail-fast: false
+      matrix:
+        system: [freebsd, openbsd, netbsd]
+    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
+
+      # --- FREEBSD ---
+      - name: Build in FreeBSD VM
+        if: matrix.system == 'freebsd'
+        uses: vmactions/freebsd-vm@v1
+        with:
+          usesh: true
+          run: |
+            export PATH="/usr/local/bin:/usr/local/sbin:$PATH"
+            pkg install -y rust perl5 gmake
+            cargo build --release
+
+      - name: Prepare FreeBSD Artifact
+        if: matrix.system == 'freebsd'
+        run: |
+          ASSET="dcr-x86_64-unknown-freebsd-${{ needs.setup.outputs.version }}"
+          cp target/release/dcr "$ASSET"
+          echo "BSD_ASSET=${ASSET}" >> "$GITHUB_ENV"
+
+      # --- OPENBSD ---
+      - name: Build in OpenBSD VM
+        if: matrix.system == 'openbsd'
+        uses: vmactions/openbsd-vm@v1
+        with:
+          usesh: true
+          run: |
+            export PATH="/usr/local/bin:$PATH"
+            pkg_add rust perl gmake
+            cargo build --release
+
+      - name: Prepare OpenBSD Artifact
+        if: matrix.system == 'openbsd'
+        run: |
+          ASSET="dcr-x86_64-unknown-openbsd-${{ needs.setup.outputs.version }}"
+          cp target/release/dcr "$ASSET"
+          echo "BSD_ASSET=${ASSET}" >> "$GITHUB_ENV"
+
+      # --- NETBSD ---
+      - name: Build in NetBSD VM
+        if: matrix.system == 'netbsd'
+        uses: vmactions/netbsd-vm@v1
+        with:
+          usesh: true
+          run: |
+            pkg_add rust perl gmake
+            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
+
+      - name: Prepare NetBSD Artifact
+        if: matrix.system == 'netbsd'
+        run: |
+          ASSET="dcr-x86_64-unknown-netbsd-${{ needs.setup.outputs.version }}"
+          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
+        with:
+          tag_name: ${{ needs.setup.outputs.tag }}
+          files: ${{ env.BSD_ASSET }}
+          body_path: .github/release-notes.md
+          prerelease: ${{ needs.setup.outputs.prerelease == 'true' }}
+
+  # ── Windows Matrix ─────────────────────────────────────────────────────────
+  build-windows:
+    if: ${{ github.event_name == 'push' || github.event.inputs.run_windows == 'true' }}
+    needs: [setup, notes]
+    runs-on: windows-latest
+    strategy:
+      fail-fast: false
+      matrix:
+        include:
+          - target: x86_64-pc-windows-msvc
+          - target: aarch64-pc-windows-msvc
+          - target: x86_64-pc-windows-gnu
+    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: Setup Rust
+        uses: dtolnay/rust-toolchain@stable
+        with:
+          targets: ${{ matrix.target }}
+
+      - name: Build
+        run: cargo build --release --target ${{ matrix.target }}
+
+      - name: Prepare Artifact
+        shell: pwsh
+        run: |
+          $asset = "dcr-${{ matrix.target }}-${{ needs.setup.outputs.version }}.exe"
+          Copy-Item "target/${{ matrix.target }}/release/dcr.exe" "$asset"
+          "ASSET_NAME=$asset" >> $env:GITHUB_ENV
+
+      - name: Upload Release Asset
+        uses: softprops/action-gh-release@v2
+        with:
+          tag_name: ${{ needs.setup.outputs.tag }}
+          files: ${{ env.ASSET_NAME }}
+          body_path: .github/release-notes.md
+          prerelease: ${{ needs.setup.outputs.prerelease == 'true' }}
+ 
+  # ── Arch User Repository (dcr) ───────────────────────────────────
+  publish-aur:
+    if: ${{ (github.event_name == 'push' && needs.setup.outputs.prerelease == 'false') || github.event.inputs.run_aur == '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='${{ needs.setup.outputs.version }}'
+          SRC_URL='${{ steps.meta.outputs.source_url }}'
+          SHA256='${{ steps.meta.outputs.sha256 }}'
+
+          mkdir -p packages/aur/dcr
+          cat > packages/aur/dcr/PKGBUILD <<PKG
+          pkgname=dcr
+          pkgver=${PKGVER}
+          pkgrel=1
+          pkgdesc="Cargo-like utility to manage C/C++ projects"
+          arch=('x86_64' 'aarch64')
+          url="https://github.com/dexoron/dcr"
+          license=('GPL-3.0-or-later')
+          depends=('gcc-libs')
+          makedepends=('cargo')
+          options=('!lto')
+          optdepends=(
+            'gcc: build C/C++ projects with GCC'
+            'clang: build C/C++ projects with Clang'
+          )
+          source=("\$pkgname-\$pkgver.tar.gz::\$url/archive/refs/tags/v\$pkgver.tar.gz")
+          sha256sums=('${SHA256}')
+
+          build() {
+            cd "\$srcdir/\$pkgname-\$pkgver"
+            export CARGO_PROFILE_RELEASE_LTO=false
+            export RUSTFLAGS="\${RUSTFLAGS:-}"
+            export RUSTFLAGS="\${RUSTFLAGS/-C link-arg=-fuse-ld=lld/}"
+            cargo build --release --locked
+          }
+
+          package() {
+            cd "\$srcdir/\$pkgname-\$pkgver"
+            install -Dm755 "target/release/dcr" "\$pkgdir/usr/bin/dcr"
+            install -Dm644 LICENSE "\$pkgdir/usr/share/licenses/\$pkgname/LICENSE"
+          }
+          PKG
+
+          cat > packages/aur/dcr/.SRCINFO <<SRC
+          pkgbase = dcr
+            pkgdesc = Cargo-like utility to manage C/C++ projects
+            pkgver = ${PKGVER}
+            pkgrel = 1
+            url = https://github.com/dexoron/dcr
+            arch = x86_64
+            arch = aarch64
+            license = GPL-3.0-or-later
+            makedepends = cargo
+            depends = gcc-libs
+            optdepends = gcc: build C/C++ projects with GCC
+            optdepends = clang: build C/C++ projects with Clang
+            options = !lto
+            source = dcr-${PKGVER}.tar.gz::${SRC_URL}
+            sha256sums = ${SHA256}
+
+          pkgname = dcr
+          SRC
+
+      - name: Push to AUR
+        env:
+          AUR_SSH_PRIVATE_KEY: ${{ secrets.AUR_SSH_PRIVATE_KEY }}
+          AUR_PACKAGE: dcr
+        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'
+          git clone "ssh://aur@aur.archlinux.org/${AUR_PACKAGE}.git" aur-repo
+          cp packages/aur/dcr/PKGBUILD aur-repo/PKGBUILD
+          cp packages/aur/dcr/.SRCINFO aur-repo/.SRCINFO
+
+          cd aur-repo
+          git config user.name "github-actions[bot]"
+          git config user.email "github-actions[bot]@users.noreply.github.com"
+
+          if git diff --quiet; then
+            echo "No AUR changes"
+            exit 0
+          fi
+
+          git add PKGBUILD .SRCINFO
+          git commit -m "dcr ${{ needs.setup.outputs.version }}"
+          git push
+
+  # ── Arch User Repository (dcr-bin) ────────────────────────────────
+  publish-aur-bin:
+    if: ${{ (github.event_name == 'push' && needs.setup.outputs.prerelease == 'false') || github.event.inputs.run_aur == '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
+          BIN_URL="https://github.com/dexoron/dcr/releases/download/${{ needs.setup.outputs.tag }}/dcr-x86_64-unknown-linux-musl-${{ needs.setup.outputs.version }}"
+          SHA256="$(curl -fsSL "$BIN_URL" | sha256sum | awk '{print $1}')"
+          echo "bin_url=$BIN_URL" >> "$GITHUB_OUTPUT"
+          echo "sha256=$SHA256" >> "$GITHUB_OUTPUT"
+
+      - name: Render AUR Metadata
+        shell: bash
+        run: |
+          set -euo pipefail
+          PKGVER='${{ needs.setup.outputs.version }}'
+          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}
+          pkgrel=1
+          pkgdesc="Cargo-like utility to manage C/C++ projects (pre-compiled musl binary)"
+          arch=('x86_64')
+          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::${BIN_URL}")
+          sha256sums_x86_64=('${SHA256}')
+
+          package() {
+            install -Dm755 "\$srcdir/dcr-\$pkgver" "\$pkgdir/usr/bin/dcr"
+          }
+          PKG
+
+          cat > packages/aur/dcr-bin/.SRCINFO <<SRC
+          pkgbase = dcr-bin
+            pkgdesc = Cargo-like utility to manage C/C++ projects (pre-compiled musl binary)
+            pkgver = ${PKGVER}
+            pkgrel = 1
+            url = https://github.com/dexoron/dcr
+            arch = x86_64
+            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}::${BIN_URL}
+            sha256sums_x86_64 = ${SHA256}
+
+          pkgname = dcr-bin
+          SRC
+
+      - name: Push to AUR
+        env:
+          AUR_SSH_PRIVATE_KEY: ${{ secrets.AUR_SSH_PRIVATE_KEY }}
+          AUR_PACKAGE: dcr-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'
+          git clone "ssh://aur@aur.archlinux.org/${AUR_PACKAGE}.git" aur-repo
+          cp packages/aur/dcr-bin/PKGBUILD aur-repo/PKGBUILD
+          cp packages/aur/dcr-bin/.SRCINFO aur-repo/.SRCINFO
+
+          cd aur-repo
+          git config user.name "github-actions[bot]"
+          git config user.email "github-actions[bot]@users.noreply.github.com"
+
+          if git diff --quiet; then
+            echo "No AUR changes"
+            exit 0
+          fi
+
+          git add PKGBUILD .SRCINFO
+          git commit -m "dcr-bin ${{ needs.setup.outputs.version }}"
+          git push
+
+  # ── crates.io ──────────────────────────────────────────────────────────────
+  publish-crates:
+    if: |
+      (github.event_name == 'push' && needs.setup.outputs.prerelease == 'false') ||
+      (github.event_name == 'workflow_dispatch' && github.event.inputs.run_publish == 'true')
+    needs: [setup, build-linux, build-macos, build-windows, build-bsd]
+    runs-on: ubuntu-latest
+    permissions:
+      contents: read
+      id-token: write
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          ref: ${{ needs.setup.outputs.tag }}
+
+      - uses: dtolnay/rust-toolchain@stable
+
+      - name: Publish to crates.io
+        run: cargo publish
+
+  # ── Homebrew tap ───────────────────────────────────────────────────────────
+  publish-brew:
+    if: |
+      (github.event_name == 'push' && needs.setup.outputs.prerelease == 'false') ||
+      (github.event_name == 'workflow_dispatch' && github.event.inputs.run_brew == 'true')
+    needs: [setup, build-linux, build-macos]
+    runs-on: ubuntu-latest
+    steps:
+      - name: Download release assets and compute sha256
+        id: sha
+        run: |
+          VERSION="${{ needs.setup.outputs.version }}"
+          BASE="https://github.com/dexoron/dcr/releases/download/v${VERSION}"
+
+          download_sha() {
+            curl -fsSL "${BASE}/$1" | sha256sum | awk '{print $1}'
+          }
+
+          echo "linux_x86=$(download_sha "dcr-x86_64-unknown-linux-gnu-${VERSION}")"     >> "$GITHUB_OUTPUT"
+          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"
+
+      - name: Checkout homebrew-dexoron
+        uses: actions/checkout@v4
+        with:
+          repository: dexoron/homebrew-dexoron
+          token: ${{ secrets.HOMEBREW_TAP_TOKEN }}
+
+      - name: Update Formula/dcr.rb
+        run: |
+          VERSION="${{ needs.setup.outputs.version }}"
+          cat > Formula/dcr.rb <<FORMULA
+          class Dcr < Formula
+            desc "Cargo-like utility to manage C/C++ projects"
+            homepage "https://dcr.dexoron.su"
+            version "${VERSION}"
+
+            on_macos do
+              on_intel do
+                url "https://github.com/dexoron/dcr/releases/download/v#{version}/dcr-x86_64-apple-darwin-#{version}"
+                sha256 "${{ steps.sha.outputs.macos_x86 }}"
+              end
+              on_arm do
+                url "https://github.com/dexoron/dcr/releases/download/v#{version}/dcr-aarch64-apple-darwin-#{version}"
+                sha256 "${{ steps.sha.outputs.macos_arm }}"
+              end
+            end
+
+            on_linux do
+              on_intel do
+                url "https://github.com/dexoron/dcr/releases/download/v#{version}/dcr-x86_64-unknown-linux-gnu-#{version}"
+                sha256 "${{ steps.sha.outputs.linux_x86 }}"
+              end
+              on_arm do
+                url "https://github.com/dexoron/dcr/releases/download/v#{version}/dcr-aarch64-unknown-linux-gnu-#{version}"
+                sha256 "${{ steps.sha.outputs.linux_arm }}"
+              end
+            end
+
+            def install
+              bin.install Dir["dcr*"].first => "dcr"
+            end
+
+            test do
+              system "#{bin}/dcr", "--version"
+            end
+          end
+          FORMULA
+
+      - name: Commit and push
+        run: |
+          git config user.name "github-actions[bot]"
+          git config user.email "github-actions[bot]@users.noreply.github.com"
+          git add Formula/dcr.rb
+          git diff --staged --quiet && echo "No changes" && exit 0
+          git commit -m "dcr ${{ needs.setup.outputs.version }}"
+          git push

.gitignore

@@ -2,4 +2,6 @@ target/
 sandbox/**
 .idea/
 .vscode/
-.env
+.env
+
+personal/

AGENT.md

@@ -1,77 +0,0 @@
-# AGENT.md
-
-## Project Overview
-
-**DCR (Dexoron Cargo Realization)** — CLI tool for managing C/C++/ASM projects in a Cargo-style.
-
-- **Implementation Language**: Rust (edition 2024)
-- **License**: MIT
-- **Repository**: [github.com/dexoron/dcr](https://github.com/dexoron/dcr)
-
-## Architecture
-
-### Source Tree (`src/`)
-
-```
-src/
-├── main.rs          # Entry point, CLI command routing
-├── config.rs        # Global constants
-├── cli/             # CLI command implementation
-│   ├── new.rs       # dcr new <name>
-│   ├── init.rs      # dcr init
-│   ├── setup.rs     # dcr setup (registry initialization)
-│   ├── add.rs       # dcr add <name>
-│   ├── build.rs     # dcr build
-│   ├── run.rs       # dcr run
-│   ├── clean.rs     # dcr clean
-│   ├── help.rs      # dcr --help
-│   └── flag_update.rs  # dcr --update
-├── core/            # Business logic
-│   ├── config.rs    # dcr.toml parsing
-│   ├── registry.rs  # Package index management (RegistryManager)
-│   ├── deps/        # Dependency resolution (path, git)
-│   ├── runner.rs    # Binary execution
-│   ├── workspace.rs # [workspace] support
-│   └── builder/     # Compiler backends (gcc, clang, msvc, nasm, gas)
-├── platform/        # Platform-specific logic
-└── utils/           # Helper utilities
-```
-
-### Key Concepts
-
-- **`~/.dcr/`**: Centralized storage for registries and configurations.
-- **`config.toml`**: File in `~/.dcr/` defining available package indices and their priorities.
-- **`dcr.toml`**: Local project configuration.
-- **Registry System**: `RegistryManager` handles package discovery across multiple indices based on priority.
-
-## Supported Platforms
-
-| Platform | Target triple |
-|---|---|
-| Linux | `x86_64-unknown-linux-gnu` |
-| macOS Intel | `x86_64-apple-darwin` |
-| macOS ARM | `aarch64-apple-darwin` |
-| Windows | `x86_64-pc-windows-msvc` |
-
-## Dependencies (Cargo)
-
-| Crate | Purpose |
-|---|---|
-| `reqwest` | HTTP requests |
-| `serde` | Serialization |
-| `toml` | Configuration parsing |
-| `git2` | Git dependency handling |
-
-## Development
-
-### Build & Run
-```bash
-cargo build --release
-./target/release/dcr setup
-```
-
-## Code Conventions
-- Rust stable edition 2024.
-- `cargo fmt` and `cargo clippy -- -D warnings`.
-- CLI output in English.
-- Use `utils::log` for messaging.

AGENTS.md

@@ -0,0 +1,56 @@
+# 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,147 @@
 # Changelog
 
+## [0.6.9] - 2026-05-28
+
+Added:
+
+- **Dexoron Packages Index** — new standalone CI workflow (`.github/workflows/dexoron-packages-index.yml`)
+  that automatically updates the `dexoron/packages` repository indexes after a release.
+  Supports Arch Linux (`repo-add`), Debian (`dpkg-scanpackages`), and Fedora (`createrepo_c`).
+  Triggered by `workflow_dispatch` or `workflow_run` on the Release workflow.
+
+- **Arch Linux native package** (`.pkg.tar.zst`) build inside the release workflow —
+  builds from source in an `archlinux:latest` Docker container using a dynamically
+  generated PKGBUILD.
+
+- **AUR publish support** — new `run_aur` workflow dispatch input and `publish-aur` /
+  `publish-aur-bin` jobs that push PKGBUILD / `.SRCINFO` to `aur.archlinux.org`.
+
+Changed:
+
+- **Release workflow refactored** — Linux packages (deb, rpm, snap, arch) and BSD
+  builds now use `strategy.matrix` instead of separate jobs. A new
+  `publish-dexoron-packages` job collects all package artifacts and uploads them
+  to the GitHub Release in one step. Removed standalone `build-arch-package`,
+  `build-snap`, `build-deb-rpm` jobs. The old `run_arch_native` input is now
+  `run_linux_packages`.
+
+- **Dexoron Packages Index workflow** extracted from `release.yml` into its own
+  file with support for Debian and RPM repository indexes in addition to Arch.
+
+- **git2 vendoring** — enabled `vendored-libgit2` and `vendored-openssl` features
+  for reproducible CI builds without system libraries.
+
+- **cargo-generate-rpm metadata** — updated to the current `package.metadata.rpm`
+  format (uses `files` table instead of `assets` array).
+
+Fixed:
+
+- **`--target=<triple>` no longer passed to GCC** — the flag is now only injected into
+  cflags when the resolved compiler name contains `"clang"`. GCC rejects this flag
+  with `unrecognized command-line option`.
+
+- **Workspace clean test** — removed assertions for member-local `target/`
+  directories. Workspace members share the root `target/` directory, so their
+  individual `src/<name>/target/` is never created.
+
+- **Release build test path** — corrected expected directory from `target/release`
+  to `target/x86_64-unknown-linux-gnu/release`.
+
+## [0.6.8] - 2026-05-27
+
+Added:
+
+- `build.cxx_standard` — separate C++ language standard for `.cpp`/`.cxx`/`.cc` files.
+  When set, overrides `build.standard` for C++ sources. Example:
+
+  ```toml
+  [build]
+  language = ["c", "c++"]
+  standard = "gnu11"
+  cxx_standard = "gnu++17"
+  ```
+
+- Variable substitution for `cflags`, `ldflags`, and `include` directory entries.
+  All `{version}`, `{version_major}`, `{name}`, `{profile}` and other step variables
+  are now available. Example:
+
+  ```toml
+  [build]
+  cflags = ['-DPROJECT_VERSION="{version}"']
+  ```
+
+- FreeBSD build support in CI — new `run_bsd` workflow input and `build-bsd` job
+  that cross-compiles `x86_64-unknown-freebsd` via `cargo-zigbuild`.
+
+Changed:
+
+- License changed from MIT to **GPL-3.0-or-later**. All source files now carry
+  the GPL-3.0 header. Default license in `dcr new` / `dcr init` changed to
+  `"GPL-3.0-or-later"`. README, FAQ, and CONTRIBUTING.md updated accordingly.
+- `get_list_with_profile_and_target` no longer duplicates list values when
+  `inherit = true` and the profile/target value is identical to the base value.
+
+Fixed:
+
+- Multi-language `language` array (e.g. `["c", "c++", "asm"]`) no longer drops `c++`
+  during internal parsing — `.cxx`/`.cpp`/`.cc` source files are correctly discovered
+  and compiled.
+- `-std=` flag is no longer passed to C++ files when only `standard` (C standard) is
+  configured — uses `cxx_standard` when available, otherwise skips `-std=` for C++
+  sources, avoiding clang error `invalid argument '-std=c11' not allowed with 'C++'`.
+- Object file collision: source files with the same stem but different extensions
+  (e.g. `gdt.cxx` and `gdt.S`) no longer overwrite each other. Object filenames
+  now include the original source extension (e.g. `gdt.cxx.o`, `gdt.S.o`).
+- MSVC backend compile step now detects language per source file extension instead
+  of using the global `language` field, fixing mixed C/C++ compilation with MSVC.
+- Assembler `-x` flag in `unix_cc.rs` and `gen.rs` is now placed **before** the
+  source file, as required by clang/gcc.
+- `{version}` variables in `build.clean` are now correctly substituted.
+
+## [0.6.7] - 2026-05-26
+
+Added:
+
+- `build.kind = "efi"` — UEFI PE32+ executable support. Links with `-shared -nostdlib -Wl,-dll -Wl,--subsystem,10`, output via `efi_path()` with `.efi` extension, rejected by `dcr run`.
+- `build.kind = "elf"` — bare-metal ELF executable support. Uses `elf_path()` output path, rejected by `dcr run`, no extra linker flags.
+- `build.filename` and `build.extension` in `dcr.toml` — complete control over the final artifact name without relying on `package.name`.
+  Example:
+
+  ```toml
+  [build]
+  filename = "KERNEL"
+  extension = "EFI"
+  ```
+
+  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.
+- `dcr build --verbose` — prints compiler/linker command lines (also works with `DCR_DEBUG` env var).
+- `dcr add <name>` without a source argument — if a registry is configured, DCR looks up the package by name and adds it as a version dependency.
+
+Fixed:
+
+- `build.target` declared in `dcr.toml` is now correctly used as the default target even when `--target` is not passed on the command line (previously the host target was always forced for config resolution).
+- `dcr run` with `--target` or `build.target` now correctly finds the binary in the arch-specific target directory.
+- `dcr run` checks profile-specific `build.{profile}.kind` before rejecting library builds (previously only checked `build.kind`).
+- `dcr clean` now reads `build.target` from `dcr.toml` when no `--target` flag is given.
+- Linux: target directory is now consistent — `target/<arch>-unknown-linux-gnu/<profile>/` (no stale `target/<profile>/`).
+- `dcr.lock` is now populated with all resolved dependencies (registry, path, git) instead of being always empty.
+- Git dependencies are now properly recognized and recorded in `dcr.lock`.
+- `is_registry_dep` correctly identifies version-based registry dependency tables (`{ version = "..." }`) and rejects tables with unknown keys.
+- `dcr test` accepts `--debug`/`--release` flags (defaults to `debug` profile instead of always `release`).
+- Build fingerprint cache (`build_cache_path`) now includes `target_dir` — different targets no longer share a single cache entry.
+- `object_path` no longer hardcodes the `src/` prefix — works correctly with custom `build.roots` (e.g. `roots = ["lib"]`).
+- `dcr update` now generates `.exe` candidates for all Windows targets, not just `x86_64-pc-windows-msvc`.
+- Compiler existence is verified before starting the build (clear error if compiler is not found in PATH).
+- Consolidated duplicate `OUTPUT_MUTEX` definitions — MSVC backend now uses the shared mutex from `common.rs`.
+- Registry cache root directory is created if missing (prevents cryptic errors when `~/.dcr/` does not exist).
+
+Changed:
+
+- `openssl` dependency is now conditional (`cfg(not(windows))`) — no longer pulled in on Windows, fixing Windows CI builds that lack Perl `Locale::Maketext::Simple`. On Linux (including musl cross-compilation) the vendored OpenSSL build is unchanged.
+
 ## [0.6.6] - 2026-05-18
 
 Fixed:
@@ -29,8 +171,9 @@ between `cli/build.rs`, `cli/run.rs`, `cli/clean.rs`, `cli/gen.rs`
 `package_root_from_registry_info`, `registry_include_dir`, `registry_lib_dir`,
 `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`)
+  `deps/mod.rs` (`path_dep_path`, `push_default_lib_dirs`),
+  `utils/build.rs` (`normalize_target_os`, `parse_version_info`)
+- `dcr tree` command — visual dependency tree viewer (similar to `cargo tree`)
 
 Removed:
 
@@ -115,10 +258,10 @@ Added:
 Added:
 
 - `dcr gen` command for IDE integration and build tool support
-    - `dcr gen project-info`: Output project metadata as JSON
-    - `dcr gen compile-commands`: Generate `compile_commands.json` for clangd and clang-tidy
-    - `dcr gen vscode`: Generate VS Code `.vscode/` integration (launch.json, tasks.json, settings.json)
-    - `dcr gen clion`: Generate JetBrains CLion `.idea/` integration (run configurations, build targets)
+- - `dcr gen project-info`: Output project metadata as JSON
+- - `dcr gen compile-commands`: Generate `compile_commands.json` for clangd and clang-tidy
+- - `dcr gen vscode`: Generate VS Code `.vscode/` integration (launch.json, tasks.json, settings.json)
+- - `dcr gen clion`: Generate JetBrains CLion `.idea/` integration (run configurations, build targets)
 - Full workspace support for all `gen` subcommands
 
 ## [0.2.10] - 2026-03-16

CONTRIBUTING.md

@@ -31,7 +31,8 @@ DCR supports cross-compilation via `--target <triple>` or short names:
 - `dcr build --target windows --release` (maps to `x86_64-pc-windows-msvc`)
 - Full triples: `dcr build --target aarch64-linux-gnu --release`
 - Configure multiple targets in `dcr.toml`:
-  ```
+
+  ```toml
   [build.targets]
   targets = ["linux", "macos"]
 
@@ -41,6 +42,7 @@ DCR supports cross-compilation via `--target <triple>` or short names:
   [build.macos]
   compiler = "clang"
   ```
+
 - If no `--target`, builds for targets in `build.targets` or native if empty.
 
 ## Checks
@@ -70,10 +72,15 @@ cargo test
 - In PRs, include a short description and rationale.
 - Update documentation when behavior changes.
 
+## License
+
+This project is licensed under the **GNU General Public License v3.0**. By contributing, you agree that your contributions will be licensed under the same license.
+
 ## Questions
 
 If anything is unclear, open an issue or ask in the PR.
 
 You can also reach out directly:
+
 - TG: @dexoron
 - DS: dexoron

Cargo.lock

@@ -112,11 +112,12 @@ dependencies = [
 
 [[package]]
 name = "dcr"
-version = "0.6.6"
+version = "0.6.9"
 dependencies = [
  "ctrlc",
  "git2",
  "glob",
+ "openssl",
  "reqwest",
  "self-replace",
  "serde",
@@ -192,6 +193,21 @@ version = "0.1.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "d9c4f5dac5e15c24eb999c26181a6ca40b39fe946cbe4c263c7209467bc83af2"
 
+[[package]]
+name = "foreign-types"
+version = "0.3.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f6f339eb8adc052cd2ca78910fda869aefa38d22d5cb648e6485e4d3fc06f3b1"
+dependencies = [
+ "foreign-types-shared",
+]
+
+[[package]]
+name = "foreign-types-shared"
+version = "0.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "00b0228411908ca8685dba7fc2cdd70ec9990a6e753e89b6ac91a84c40fbaf4b"
+
 [[package]]
 name = "form_urlencoded"
 version = "1.2.2"
@@ -730,12 +746,46 @@ version = "1.21.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "42f5e15c9953c5e4ccceeb2e7382a716482c34515315f7b03532b8b4e8393d2d"
 
+[[package]]
+name = "openssl"
+version = "0.10.79"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bf0b434746ee2832f4f0baf10137e1cabb18cbe6912c69e2e33263c45250f542"
+dependencies = [
+ "bitflags",
+ "cfg-if",
+ "foreign-types",
+ "libc",
+ "openssl-macros",
+ "openssl-sys",
+]
+
+[[package]]
+name = "openssl-macros"
+version = "0.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a948666b637a0f465e8564c73e89d4dde00d72d4d473cc972f390fc3dcee7d9c"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
 [[package]]
 name = "openssl-probe"
 version = "0.1.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "d05e27ee213611ffe7d6348b942e8f942b37114c00cc03cec254295a4a17852e"
 
+[[package]]
+name = "openssl-src"
+version = "300.6.0+3.6.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a8e8cbfd3a4a8c8f089147fd7aaa33cf8c7450c4d09f8f80698a0cf093abeff4"
+dependencies = [
+ "cc",
+]
+
 [[package]]
 name = "openssl-sys"
 version = "0.9.115"
@@ -744,6 +794,7 @@ checksum = "158fe5b292746440aa6e7a7e690e55aeb72d41505e2804c23c6973ad0e9c9781"
 dependencies = [
  "cc",
  "libc",
+ "openssl-src",
  "pkg-config",
  "vcpkg",
 ]

Cargo.toml

@@ -1,8 +1,37 @@
 [package]
 name = "dcr"
-version = "0.6.6"
+version = "0.6.9"
 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"
+
+[package.metadata.binstall]
+pkg-fmt = "bin"
+pkg-url = "{ repo }/releases/download/v{ version }/dcr-{ target }-{ version }{ bin-suffix }"
+
+[package.metadata.deb]
+maintainer = "Dexoron (Bezotechestvo Vladimir) <main@dexoron.su>"
+copyright = "2026, Dexoron"
+extended-description = """
+Cargo-like utility to manage C/C++ projects.
+"""
+section = "devel"
+priority = "optional"
+assets = [
+    ["target/release/dcr", "usr/bin/dcr", "755"],
+]
+
+[package.metadata.generate-rpm]
+summary = "Cargo-like utility to manage C/C++ projects"
+description = """
+Cargo-like utility to manage C/C++ projects.
+"""
+
+assets = [
+    { source = "target/release/dcr", dest = "/usr/bin/dcr", mode = "755" }
+]
 
 [dependencies]
 glob = "0.3"
@@ -11,6 +40,9 @@ serde = { version = "1", features = ["derive"] }
 self-replace = "1"
 sha2 = "0.10"
 toml = "1.0.3"
-git2 = "0.20.4"
 serde_json = "1"
 ctrlc = "3"
+git2 = { version = "0.20.4", features = ["vendored-libgit2", "vendored-openssl"] }
+
+[target.'cfg(not(windows))'.dependencies]
+openssl = { version = "0.10", features = ["vendored"] }

FAQ.md

@@ -1,38 +1,46 @@
 # FAQ
 
 ## What is this project about?
+
 `dcr` is a tool for managing C/C++ projects and their dependencies.
 It is inspired by Cargo, but it is not a direct equivalent of Makefile, CMake, or other classic build systems.
 
 The goal is to provide a simpler and easier-to-configure development workflow.
 
 ## How is the project developed?
+
 The project is written in Rust and is primarily developed by one maintainer, Dexoron.
 
 AI tools are used during development, but they do not write the project end-to-end. Their role is limited to supporting specific tasks (for example, suggestions, wording checks, and translations).
 
 ## Which tools are used for development?
+
 Main development stack:
+
 - `RustRover` 2025 - development IDE.
 - `Codex` (`GPT-5.3-Codex (medium)`) - primary AI tool, integrated via JetBrains AI Chat.
 - `Rust` - main project language.
 - `Cargo` - tool for building, testing, and dependency management in Rust projects.
 
 ## Is the project open source?
+
 Yes, the project is open source.
 You can propose ideas, report issues, and contribute code changes.
 
-The project is distributed under the MIT license (see `LICENSE`).
+The project is distributed under the GPL-3.0 license (see `LICENSE`).
 
 ## How can I contribute?
+
 Thank you for contributing.
 You can:
+
 - help with code;
 - help with translations;
 - help with documentation;
 - suggest an idea or report a bug.
 
 ### If you want to submit changes (code, translation, documentation)
+
 1. Fork the required repository: `dexoron/dcr` (main project) or `dexoron/dcr-site` (project website).
 2. Make your changes following the rules in `CONTRIBUTING.md`.
 3. Push changes to your fork.
@@ -40,6 +48,7 @@ You can:
 5. Wait for review.
 
 ### If you want to report a problem or suggest an idea
+
 1. Open the relevant repository: `dexoron/dcr` or `dexoron/dcr-site`.
 2. Go to the `Issues` tab.
 3. Create an Issue and specify its type (bug, suggestion, question/help).
@@ -47,13 +56,17 @@ You can:
 5. Wait for feedback.
 
 ## How do I install `dcr`?
+
 Available installation methods may vary by project version.
 Recommended path:
+
 - check instructions in `README.md`;
 - if there is no prebuilt package for your platform, build from source using `cargo build --release`.
 
 ## How can I get started quickly?
+
 Minimal workflow:
+
 1. Install `dcr`.
 2. Create a project (or open an existing C/C++ project).
 3. Initialize `dcr` configuration.
@@ -63,21 +76,25 @@ Minimal workflow:
 For detailed commands and examples, see `README.md` and the project documentation.
 
 ## What is the project status?
+
 `dcr` is under active development.
 This means some interfaces and behaviors may change between versions.
 
 Before upgrading, check the changelog and release notes.
 
 ## Which systems does `dcr` support?
+
 `dcr` targets modern C/C++ development environments.
 Actual compatibility depends on the `dcr` version, operating system, and toolchain.
 
 Before starting, check documentation for:
+
 - supported operating systems;
 - supported compilers and linkers;
 - version-specific limitations.
 
 ## How is `dcr` different from Make/CMake?
+
 `dcr` does not aim to be a direct replacement for Make/CMake.
 Its main focus is simplifying project and dependency management with a Cargo-like experience.
 
@@ -85,13 +102,17 @@ If you need low-level, full control over build steps, classic tools may be a bet
 If you want a simpler and more uniform configuration model, `dcr` may be more convenient.
 
 ## Where can I find documentation and examples?
+
 Primary sources:
+
 - `README.md` in the repository;
 - project documentation (see the project website);
 - `Issues` for known problems and discussions.
 
 ## How do I report a bug properly?
+
 To make a bug report easy to reproduce, include:
+
 1. `dcr` version.
 2. OS and compiler/toolchain version.
 3. Steps to reproduce.

LICENSE

@@ -1,21 +1,675 @@
-MIT License
+# GNU GENERAL PUBLIC LICENSE
 
-Copyright (c) 2026 Dexoron (Bezotechestvo Vladimir) [main@dexoron.su]
+Version 3, 29 June 2007
 
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
+Copyright (C) 2007 Free Software Foundation, Inc.
+<https://fsf.org/>
 
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
+Everyone is permitted to copy and distribute verbatim copies of this
+license document, but changing it is not allowed.
 
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.
+## Preamble
+
+The GNU General Public License is a free, copyleft license for
+software and other kinds of works.
+
+The licenses for most software and other practical works are designed
+to take away your freedom to share and change the works. By contrast,
+the GNU General Public License is intended to guarantee your freedom
+to share and change all versions of a program--to make sure it remains
+free software for all its users. We, the Free Software Foundation, use
+the GNU General Public License for most of our software; it applies
+also to any other work released this way by its authors. You can apply
+it to your programs, too.
+
+When we speak of free software, we are referring to freedom, not
+price. Our General Public Licenses are designed to make sure that you
+have the freedom to distribute copies of free software (and charge for
+them if you wish), that you receive source code or can get it if you
+want it, that you can change the software or use pieces of it in new
+free programs, and that you know you can do these things.
+
+To protect your rights, we need to prevent others from denying you
+these rights or asking you to surrender the rights. Therefore, you
+have certain responsibilities if you distribute copies of the
+software, or if you modify it: responsibilities to respect the freedom
+of others.
+
+For example, if you distribute copies of such a program, whether
+gratis or for a fee, you must pass on to the recipients the same
+freedoms that you received. You must make sure that they, too, receive
+or can get the source code. And you must show them these terms so they
+know their rights.
+
+Developers that use the GNU GPL protect your rights with two steps:
+(1) assert copyright on the software, and (2) offer you this License
+giving you legal permission to copy, distribute and/or modify it.
+
+For the developers' and authors' protection, the GPL clearly explains
+that there is no warranty for this free software. For both users' and
+authors' sake, the GPL requires that modified versions be marked as
+changed, so that their problems will not be attributed erroneously to
+authors of previous versions.
+
+Some devices are designed to deny users access to install or run
+modified versions of the software inside them, although the
+manufacturer can do so. This is fundamentally incompatible with the
+aim of protecting users' freedom to change the software. The
+systematic pattern of such abuse occurs in the area of products for
+individuals to use, which is precisely where it is most unacceptable.
+Therefore, we have designed this version of the GPL to prohibit the
+practice for those products. If such problems arise substantially in
+other domains, we stand ready to extend this provision to those
+domains in future versions of the GPL, as needed to protect the
+freedom of users.
+
+Finally, every program is threatened constantly by software patents.
+States should not allow patents to restrict development and use of
+software on general-purpose computers, but in those that do, we wish
+to avoid the special danger that patents applied to a free program
+could make it effectively proprietary. To prevent this, the GPL
+assures that patents cannot be used to render the program non-free.
+
+The precise terms and conditions for copying, distribution and
+modification follow.
+
+## TERMS AND CONDITIONS
+
+### 0. Definitions.
+
+"This License" refers to version 3 of the GNU General Public License.
+
+"Copyright" also means copyright-like laws that apply to other kinds
+of works, such as semiconductor masks.
+
+"The Program" refers to any copyrightable work licensed under this
+License. Each licensee is addressed as "you". "Licensees" and
+"recipients" may be individuals or organizations.
+
+To "modify" a work means to copy from or adapt all or part of the work
+in a fashion requiring copyright permission, other than the making of
+an exact copy. The resulting work is called a "modified version" of
+the earlier work or a work "based on" the earlier work.
+
+A "covered work" means either the unmodified Program or a work based
+on the Program.
+
+To "propagate" a work means to do anything with it that, without
+permission, would make you directly or secondarily liable for
+infringement under applicable copyright law, except executing it on a
+computer or modifying a private copy. Propagation includes copying,
+distribution (with or without modification), making available to the
+public, and in some countries other activities as well.
+
+To "convey" a work means any kind of propagation that enables other
+parties to make or receive copies. Mere interaction with a user
+through a computer network, with no transfer of a copy, is not
+conveying.
+
+An interactive user interface displays "Appropriate Legal Notices" to
+the extent that it includes a convenient and prominently visible
+feature that (1) displays an appropriate copyright notice, and (2)
+tells the user that there is no warranty for the work (except to the
+extent that warranties are provided), that licensees may convey the
+work under this License, and how to view a copy of this License. If
+the interface presents a list of user commands or options, such as a
+menu, a prominent item in the list meets this criterion.
+
+### 1. Source Code.
+
+The "source code" for a work means the preferred form of the work for
+making modifications to it. "Object code" means any non-source form of
+a work.
+
+A "Standard Interface" means an interface that either is an official
+standard defined by a recognized standards body, or, in the case of
+interfaces specified for a particular programming language, one that
+is widely used among developers working in that language.
+
+The "System Libraries" of an executable work include anything, other
+than the work as a whole, that (a) is included in the normal form of
+packaging a Major Component, but which is not part of that Major
+Component, and (b) serves only to enable use of the work with that
+Major Component, or to implement a Standard Interface for which an
+implementation is available to the public in source code form. A
+"Major Component", in this context, means a major essential component
+(kernel, window system, and so on) of the specific operating system
+(if any) on which the executable work runs, or a compiler used to
+produce the work, or an object code interpreter used to run it.
+
+The "Corresponding Source" for a work in object code form means all
+the source code needed to generate, install, and (for an executable
+work) run the object code and to modify the work, including scripts to
+control those activities. However, it does not include the work's
+System Libraries, or general-purpose tools or generally available free
+programs which are used unmodified in performing those activities but
+which are not part of the work. For example, Corresponding Source
+includes interface definition files associated with source files for
+the work, and the source code for shared libraries and dynamically
+linked subprograms that the work is specifically designed to require,
+such as by intimate data communication or control flow between those
+subprograms and other parts of the work.
+
+The Corresponding Source need not include anything that users can
+regenerate automatically from other parts of the Corresponding Source.
+
+The Corresponding Source for a work in source code form is that same
+work.
+
+### 2. Basic Permissions.
+
+All rights granted under this License are granted for the term of
+copyright on the Program, and are irrevocable provided the stated
+conditions are met. This License explicitly affirms your unlimited
+permission to run the unmodified Program. The output from running a
+covered work is covered by this License only if the output, given its
+content, constitutes a covered work. This License acknowledges your
+rights of fair use or other equivalent, as provided by copyright law.
+
+You may make, run and propagate covered works that you do not convey,
+without conditions so long as your license otherwise remains in force.
+You may convey covered works to others for the sole purpose of having
+them make modifications exclusively for you, or provide you with
+facilities for running those works, provided that you comply with the
+terms of this License in conveying all material for which you do not
+control copyright. Those thus making or running the covered works for
+you must do so exclusively on your behalf, under your direction and
+control, on terms that prohibit them from making any copies of your
+copyrighted material outside their relationship with you.
+
+Conveying under any other circumstances is permitted solely under the
+conditions stated below. Sublicensing is not allowed; section 10 makes
+it unnecessary.
+
+### 3. Protecting Users' Legal Rights From Anti-Circumvention Law.
+
+No covered work shall be deemed part of an effective technological
+measure under any applicable law fulfilling obligations under article
+11 of the WIPO copyright treaty adopted on 20 December 1996, or
+similar laws prohibiting or restricting circumvention of such
+measures.
+
+When you convey a covered work, you waive any legal power to forbid
+circumvention of technological measures to the extent such
+circumvention is effected by exercising rights under this License with
+respect to the covered work, and you disclaim any intention to limit
+operation or modification of the work as a means of enforcing, against
+the work's users, your or third parties' legal rights to forbid
+circumvention of technological measures.
+
+### 4. Conveying Verbatim Copies.
+
+You may convey verbatim copies of the Program's source code as you
+receive it, in any medium, provided that you conspicuously and
+appropriately publish on each copy an appropriate copyright notice;
+keep intact all notices stating that this License and any
+non-permissive terms added in accord with section 7 apply to the code;
+keep intact all notices of the absence of any warranty; and give all
+recipients a copy of this License along with the Program.
+
+You may charge any price or no price for each copy that you convey,
+and you may offer support or warranty protection for a fee.
+
+### 5. Conveying Modified Source Versions.
+
+You may convey a work based on the Program, or the modifications to
+produce it from the Program, in the form of source code under the
+terms of section 4, provided that you also meet all of these
+conditions:
+
+-   a) The work must carry prominent notices stating that you modified
+    it, and giving a relevant date.
+-   b) The work must carry prominent notices stating that it is
+    released under this License and any conditions added under
+    section 7. This requirement modifies the requirement in section 4
+    to "keep intact all notices".
+-   c) You must license the entire work, as a whole, under this
+    License to anyone who comes into possession of a copy. This
+    License will therefore apply, along with any applicable section 7
+    additional terms, to the whole of the work, and all its parts,
+    regardless of how they are packaged. This License gives no
+    permission to license the work in any other way, but it does not
+    invalidate such permission if you have separately received it.
+-   d) If the work has interactive user interfaces, each must display
+    Appropriate Legal Notices; however, if the Program has interactive
+    interfaces that do not display Appropriate Legal Notices, your
+    work need not make them do so.
+
+A compilation of a covered work with other separate and independent
+works, which are not by their nature extensions of the covered work,
+and which are not combined with it such as to form a larger program,
+in or on a volume of a storage or distribution medium, is called an
+"aggregate" if the compilation and its resulting copyright are not
+used to limit the access or legal rights of the compilation's users
+beyond what the individual works permit. Inclusion of a covered work
+in an aggregate does not cause this License to apply to the other
+parts of the aggregate.
+
+### 6. Conveying Non-Source Forms.
+
+You may convey a covered work in object code form under the terms of
+sections 4 and 5, provided that you also convey the machine-readable
+Corresponding Source under the terms of this License, in one of these
+ways:
+
+-   a) Convey the object code in, or embodied in, a physical product
+    (including a physical distribution medium), accompanied by the
+    Corresponding Source fixed on a durable physical medium
+    customarily used for software interchange.
+-   b) Convey the object code in, or embodied in, a physical product
+    (including a physical distribution medium), accompanied by a
+    written offer, valid for at least three years and valid for as
+    long as you offer spare parts or customer support for that product
+    model, to give anyone who possesses the object code either (1) a
+    copy of the Corresponding Source for all the software in the
+    product that is covered by this License, on a durable physical
+    medium customarily used for software interchange, for a price no
+    more than your reasonable cost of physically performing this
+    conveying of source, or (2) access to copy the Corresponding
+    Source from a network server at no charge.
+-   c) Convey individual copies of the object code with a copy of the
+    written offer to provide the Corresponding Source. This
+    alternative is allowed only occasionally and noncommercially, and
+    only if you received the object code with such an offer, in accord
+    with subsection 6b.
+-   d) Convey the object code by offering access from a designated
+    place (gratis or for a charge), and offer equivalent access to the
+    Corresponding Source in the same way through the same place at no
+    further charge. You need not require recipients to copy the
+    Corresponding Source along with the object code. If the place to
+    copy the object code is a network server, the Corresponding Source
+    may be on a different server (operated by you or a third party)
+    that supports equivalent copying facilities, provided you maintain
+    clear directions next to the object code saying where to find the
+    Corresponding Source. Regardless of what server hosts the
+    Corresponding Source, you remain obligated to ensure that it is
+    available for as long as needed to satisfy these requirements.
+-   e) Convey the object code using peer-to-peer transmission,
+    provided you inform other peers where the object code and
+    Corresponding Source of the work are being offered to the general
+    public at no charge under subsection 6d.
+
+A separable portion of the object code, whose source code is excluded
+from the Corresponding Source as a System Library, need not be
+included in conveying the object code work.
+
+A "User Product" is either (1) a "consumer product", which means any
+tangible personal property which is normally used for personal,
+family, or household purposes, or (2) anything designed or sold for
+incorporation into a dwelling. In determining whether a product is a
+consumer product, doubtful cases shall be resolved in favor of
+coverage. For a particular product received by a particular user,
+"normally used" refers to a typical or common use of that class of
+product, regardless of the status of the particular user or of the way
+in which the particular user actually uses, or expects or is expected
+to use, the product. A product is a consumer product regardless of
+whether the product has substantial commercial, industrial or
+non-consumer uses, unless such uses represent the only significant
+mode of use of the product.
+
+"Installation Information" for a User Product means any methods,
+procedures, authorization keys, or other information required to
+install and execute modified versions of a covered work in that User
+Product from a modified version of its Corresponding Source. The
+information must suffice to ensure that the continued functioning of
+the modified object code is in no case prevented or interfered with
+solely because modification has been made.
+
+If you convey an object code work under this section in, or with, or
+specifically for use in, a User Product, and the conveying occurs as
+part of a transaction in which the right of possession and use of the
+User Product is transferred to the recipient in perpetuity or for a
+fixed term (regardless of how the transaction is characterized), the
+Corresponding Source conveyed under this section must be accompanied
+by the Installation Information. But this requirement does not apply
+if neither you nor any third party retains the ability to install
+modified object code on the User Product (for example, the work has
+been installed in ROM).
+
+The requirement to provide Installation Information does not include a
+requirement to continue to provide support service, warranty, or
+updates for a work that has been modified or installed by the
+recipient, or for the User Product in which it has been modified or
+installed. Access to a network may be denied when the modification
+itself materially and adversely affects the operation of the network
+or violates the rules and protocols for communication across the
+network.
+
+Corresponding Source conveyed, and Installation Information provided,
+in accord with this section must be in a format that is publicly
+documented (and with an implementation available to the public in
+source code form), and must require no special password or key for
+unpacking, reading or copying.
+
+### 7. Additional Terms.
+
+"Additional permissions" are terms that supplement the terms of this
+License by making exceptions from one or more of its conditions.
+Additional permissions that are applicable to the entire Program shall
+be treated as though they were included in this License, to the extent
+that they are valid under applicable law. If additional permissions
+apply only to part of the Program, that part may be used separately
+under those permissions, but the entire Program remains governed by
+this License without regard to the additional permissions.
+
+When you convey a copy of a covered work, you may at your option
+remove any additional permissions from that copy, or from any part of
+it. (Additional permissions may be written to require their own
+removal in certain cases when you modify the work.) You may place
+additional permissions on material, added by you to a covered work,
+for which you have or can give appropriate copyright permission.
+
+Notwithstanding any other provision of this License, for material you
+add to a covered work, you may (if authorized by the copyright holders
+of that material) supplement the terms of this License with terms:
+
+-   a) Disclaiming warranty or limiting liability differently from the
+    terms of sections 15 and 16 of this License; or
+-   b) Requiring preservation of specified reasonable legal notices or
+    author attributions in that material or in the Appropriate Legal
+    Notices displayed by works containing it; or
+-   c) Prohibiting misrepresentation of the origin of that material,
+    or requiring that modified versions of such material be marked in
+    reasonable ways as different from the original version; or
+-   d) Limiting the use for publicity purposes of names of licensors
+    or authors of the material; or
+-   e) Declining to grant rights under trademark law for use of some
+    trade names, trademarks, or service marks; or
+-   f) Requiring indemnification of licensors and authors of that
+    material by anyone who conveys the material (or modified versions
+    of it) with contractual assumptions of liability to the recipient,
+    for any liability that these contractual assumptions directly
+    impose on those licensors and authors.
+
+All other non-permissive additional terms are considered "further
+restrictions" within the meaning of section 10. If the Program as you
+received it, or any part of it, contains a notice stating that it is
+governed by this License along with a term that is a further
+restriction, you may remove that term. If a license document contains
+a further restriction but permits relicensing or conveying under this
+License, you may add to a covered work material governed by the terms
+of that license document, provided that the further restriction does
+not survive such relicensing or conveying.
+
+If you add terms to a covered work in accord with this section, you
+must place, in the relevant source files, a statement of the
+additional terms that apply to those files, or a notice indicating
+where to find the applicable terms.
+
+Additional terms, permissive or non-permissive, may be stated in the
+form of a separately written license, or stated as exceptions; the
+above requirements apply either way.
+
+### 8. Termination.
+
+You may not propagate or modify a covered work except as expressly
+provided under this License. Any attempt otherwise to propagate or
+modify it is void, and will automatically terminate your rights under
+this License (including any patent licenses granted under the third
+paragraph of section 11).
+
+However, if you cease all violation of this License, then your license
+from a particular copyright holder is reinstated (a) provisionally,
+unless and until the copyright holder explicitly and finally
+terminates your license, and (b) permanently, if the copyright holder
+fails to notify you of the violation by some reasonable means prior to
+60 days after the cessation.
+
+Moreover, your license from a particular copyright holder is
+reinstated permanently if the copyright holder notifies you of the
+violation by some reasonable means, this is the first time you have
+received notice of violation of this License (for any work) from that
+copyright holder, and you cure the violation prior to 30 days after
+your receipt of the notice.
+
+Termination of your rights under this section does not terminate the
+licenses of parties who have received copies or rights from you under
+this License. If your rights have been terminated and not permanently
+reinstated, you do not qualify to receive new licenses for the same
+material under section 10.
+
+### 9. Acceptance Not Required for Having Copies.
+
+You are not required to accept this License in order to receive or run
+a copy of the Program. Ancillary propagation of a covered work
+occurring solely as a consequence of using peer-to-peer transmission
+to receive a copy likewise does not require acceptance. However,
+nothing other than this License grants you permission to propagate or
+modify any covered work. These actions infringe copyright if you do
+not accept this License. Therefore, by modifying or propagating a
+covered work, you indicate your acceptance of this License to do so.
+
+### 10. Automatic Licensing of Downstream Recipients.
+
+Each time you convey a covered work, the recipient automatically
+receives a license from the original licensors, to run, modify and
+propagate that work, subject to this License. You are not responsible
+for enforcing compliance by third parties with this License.
+
+An "entity transaction" is a transaction transferring control of an
+organization, or substantially all assets of one, or subdividing an
+organization, or merging organizations. If propagation of a covered
+work results from an entity transaction, each party to that
+transaction who receives a copy of the work also receives whatever
+licenses to the work the party's predecessor in interest had or could
+give under the previous paragraph, plus a right to possession of the
+Corresponding Source of the work from the predecessor in interest, if
+the predecessor has it or can get it with reasonable efforts.
+
+You may not impose any further restrictions on the exercise of the
+rights granted or affirmed under this License. For example, you may
+not impose a license fee, royalty, or other charge for exercise of
+rights granted under this License, and you may not initiate litigation
+(including a cross-claim or counterclaim in a lawsuit) alleging that
+any patent claim is infringed by making, using, selling, offering for
+sale, or importing the Program or any portion of it.
+
+### 11. Patents.
+
+A "contributor" is a copyright holder who authorizes use under this
+License of the Program or a work on which the Program is based. The
+work thus licensed is called the contributor's "contributor version".
+
+A contributor's "essential patent claims" are all patent claims owned
+or controlled by the contributor, whether already acquired or
+hereafter acquired, that would be infringed by some manner, permitted
+by this License, of making, using, or selling its contributor version,
+but do not include claims that would be infringed only as a
+consequence of further modification of the contributor version. For
+purposes of this definition, "control" includes the right to grant
+patent sublicenses in a manner consistent with the requirements of
+this License.
+
+Each contributor grants you a non-exclusive, worldwide, royalty-free
+patent license under the contributor's essential patent claims, to
+make, use, sell, offer for sale, import and otherwise run, modify and
+propagate the contents of its contributor version.
+
+In the following three paragraphs, a "patent license" is any express
+agreement or commitment, however denominated, not to enforce a patent
+(such as an express permission to practice a patent or covenant not to
+sue for patent infringement). To "grant" such a patent license to a
+party means to make such an agreement or commitment not to enforce a
+patent against the party.
+
+If you convey a covered work, knowingly relying on a patent license,
+and the Corresponding Source of the work is not available for anyone
+to copy, free of charge and under the terms of this License, through a
+publicly available network server or other readily accessible means,
+then you must either (1) cause the Corresponding Source to be so
+available, or (2) arrange to deprive yourself of the benefit of the
+patent license for this particular work, or (3) arrange, in a manner
+consistent with the requirements of this License, to extend the patent
+license to downstream recipients. "Knowingly relying" means you have
+actual knowledge that, but for the patent license, your conveying the
+covered work in a country, or your recipient's use of the covered work
+in a country, would infringe one or more identifiable patents in that
+country that you have reason to believe are valid.
+
+If, pursuant to or in connection with a single transaction or
+arrangement, you convey, or propagate by procuring conveyance of, a
+covered work, and grant a patent license to some of the parties
+receiving the covered work authorizing them to use, propagate, modify
+or convey a specific copy of the covered work, then the patent license
+you grant is automatically extended to all recipients of the covered
+work and works based on it.
+
+A patent license is "discriminatory" if it does not include within the
+scope of its coverage, prohibits the exercise of, or is conditioned on
+the non-exercise of one or more of the rights that are specifically
+granted under this License. You may not convey a covered work if you
+are a party to an arrangement with a third party that is in the
+business of distributing software, under which you make payment to the
+third party based on the extent of your activity of conveying the
+work, and under which the third party grants, to any of the parties
+who would receive the covered work from you, a discriminatory patent
+license (a) in connection with copies of the covered work conveyed by
+you (or copies made from those copies), or (b) primarily for and in
+connection with specific products or compilations that contain the
+covered work, unless you entered into that arrangement, or that patent
+license was granted, prior to 28 March 2007.
+
+Nothing in this License shall be construed as excluding or limiting
+any implied license or other defenses to infringement that may
+otherwise be available to you under applicable patent law.
+
+### 12. No Surrender of Others' Freedom.
+
+If conditions are imposed on you (whether by court order, agreement or
+otherwise) that contradict the conditions of this License, they do not
+excuse you from the conditions of this License. If you cannot convey a
+covered work so as to satisfy simultaneously your obligations under
+this License and any other pertinent obligations, then as a
+consequence you may not convey it at all. For example, if you agree to
+terms that obligate you to collect a royalty for further conveying
+from those to whom you convey the Program, the only way you could
+satisfy both those terms and this License would be to refrain entirely
+from conveying the Program.
+
+### 13. Use with the GNU Affero General Public License.
+
+Notwithstanding any other provision of this License, you have
+permission to link or combine any covered work with a work licensed
+under version 3 of the GNU Affero General Public License into a single
+combined work, and to convey the resulting work. The terms of this
+License will continue to apply to the part which is the covered work,
+but the special requirements of the GNU Affero General Public License,
+section 13, concerning interaction through a network will apply to the
+combination as such.
+
+### 14. Revised Versions of this License.
+
+The Free Software Foundation may publish revised and/or new versions
+of the GNU General Public License from time to time. Such new versions
+will be similar in spirit to the present version, but may differ in
+detail to address new problems or concerns.
+
+Each version is given a distinguishing version number. If the Program
+specifies that a certain numbered version of the GNU General Public
+License "or any later version" applies to it, you have the option of
+following the terms and conditions either of that numbered version or
+of any later version published by the Free Software Foundation. If the
+Program does not specify a version number of the GNU General Public
+License, you may choose any version ever published by the Free
+Software Foundation.
+
+If the Program specifies that a proxy can decide which future versions
+of the GNU General Public License can be used, that proxy's public
+statement of acceptance of a version permanently authorizes you to
+choose that version for the Program.
+
+Later license versions may give you additional or different
+permissions. However, no additional obligations are imposed on any
+author or copyright holder as a result of your choosing to follow a
+later version.
+
+### 15. Disclaimer of Warranty.
+
+THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY
+APPLICABLE LAW. EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT
+HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM "AS IS" WITHOUT
+WARRANTY OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE. THE ENTIRE RISK AS TO THE QUALITY AND
+PERFORMANCE OF THE PROGRAM IS WITH YOU. SHOULD THE PROGRAM PROVE
+DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING, REPAIR OR
+CORRECTION.
+
+### 16. Limitation of Liability.
+
+IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
+WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MODIFIES AND/OR
+CONVEYS THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES,
+INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES
+ARISING OUT OF THE USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT
+NOT LIMITED TO LOSS OF DATA OR DATA BEING RENDERED INACCURATE OR
+LOSSES SUSTAINED BY YOU OR THIRD PARTIES OR A FAILURE OF THE PROGRAM
+TO OPERATE WITH ANY OTHER PROGRAMS), EVEN IF SUCH HOLDER OR OTHER
+PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.
+
+### 17. Interpretation of Sections 15 and 16.
+
+If the disclaimer of warranty and limitation of liability provided
+above cannot be given local legal effect according to their terms,
+reviewing courts shall apply local law that most closely approximates
+an absolute waiver of all civil liability in connection with the
+Program, unless a warranty or assumption of liability accompanies a
+copy of the Program in return for a fee.
+
+END OF TERMS AND CONDITIONS
+
+## How to Apply These Terms to Your New Programs
+
+If you develop a new program, and you want it to be of the greatest
+possible use to the public, the best way to achieve this is to make it
+free software which everyone can redistribute and change under these
+terms.
+
+To do so, attach the following notices to the program. It is safest to
+attach them to the start of each source file to most effectively state
+the exclusion of warranty; and each file should have at least the
+"copyright" line and a pointer to where the full notice is found.
+
+        <one line to give the program's name and a brief idea of what it does.>
+        Copyright (C) <year>  <name of author>
+
+        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/>.
+
+Also add information on how to contact you by electronic and paper
+mail.
+
+If the program does terminal interaction, make it output a short
+notice like this when it starts in an interactive mode:
+
+        <program>  Copyright (C) <year>  <name of author>
+        This program comes with ABSOLUTELY NO WARRANTY; for details type `show w'.
+        This is free software, and you are welcome to redistribute it
+        under certain conditions; type `show c' for details.
+
+The hypothetical commands \`show w' and \`show c' should show the
+appropriate parts of the General Public License. Of course, your
+program's commands might be different; for a GUI interface, you would
+use an "about box".
+
+You should also get your employer (if you work as a programmer) or
+school, if any, to sign a "copyright disclaimer" for the program, if
+necessary. For more information on this, and how to apply and follow
+the GNU GPL, see <https://www.gnu.org/licenses/>.
+
+The GNU General Public License does not permit incorporating your
+program into proprietary programs. If your program is a subroutine
+library, you may consider it more useful to permit linking proprietary
+applications with the library. If this is what you want to do, use the
+GNU Lesser General Public License instead of this License. But first,
+please read <https://www.gnu.org/licenses/why-not-lgpl.html>.

README.md

@@ -1,254 +1,208 @@
-# DCR (Dexoron Cargo Realization)
+<div align="center">
 
-DCR is a utility for managing C/C++ projects in a Cargo-like style.
+# DCR — Dexoron Cargo Realization
 
-The current implementation is written in Rust.
+**A Cargo-style build tool for C/C++ projects**
 
-## Why DCR
-- Unified project structure without manual setup
-- Simple commands for common tasks
-- Transparent compilation and predictable build profiles
+[![CI](https://github.com/dexoron/dcr/actions/workflows/ci.yml/badge.svg)](https://github.com/dexoron/dcr/actions/workflows/ci.yml)
+[![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)
 
-## Features
-- Create a new project or initialize the current directory
-- Build a project with `debug` and `release` profiles
-- Run the compiled binary
-- Clean build artifacts
-- Generate IDE integration files (VS Code, CLion) and compilation databases
-- Generate a minimal C project template
-- Build static and shared libraries
-- Dependency management:
-  - Git and Path dependencies with `dcr.lock`
-  - Registry-based dependency resolution
-- Library packaging functionality (auto-generate `include/` and `lib/` for `type = "lib"` packages)
-- ASM projects with NASM/GAS or via GCC/Clang
-- Mixed language projects
-- Cross-compilation with `--target` (full triple support and short names)
-- Target-specific configurations and inheritance
-- Update the binary via `dcr --update` (GitHub Releases)
+</div>
 
-## Supported Platforms
-- Linux: x86_64/aarch64 (GNU and Musl)
-- macOS: x86_64/aarch64
-- Windows: x86_64/aarch64 (MSVC, GNU, LLVM)
+---
+
+## Why DCR?
+
+- **No boilerplate** — one config file, predictable structure
+- **Cargo-like workflow** — `build`, `run`, `clean`, `test`, `add`
+- **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
+
+---
 
 ## Installation
 
-### Package Manager
-
-**Arch Linux**
-```sh
-yay -S dcr # or paru and other AUR package managers
-```
-
-### From Source
+<table>
+<tr>
+<td><b>Arch Linux (AUR)</b></td>
+<td>
 
 ```sh
-git clone https://github.com/dexoron/dcr.git
-cd dcr
-cargo build --release
-mkdir -p ~/.local/bin
-ln -sf "$PWD/target/release/dcr" ~/.local/bin/dcr
+yay -S dcr
 ```
 
-### Via `install.sh` (Linux/macOS)
+</td>
+</tr>
+<tr>
+<td><b>macOS/Linux(GNU) (Homebrew)</b></td>
+<td>
+
+```sh
+brew tap dexoron/dexoron
+brew install dcr
+```
+
+</td>
+</tr>
+<tr>
+<td><b>Cargo (crates.io)</b></td>
+<td>
+
+```sh
+cargo install dcr
+```
+
+</td>
+</tr>
+<tr>
+<td><b>Linux / macOS (script)</b></td>
+<td>
 
 ```sh
 curl -fsSL https://dcr.dexoron.su/install.sh | bash
 ```
 
-### Via `install.ps1` (Windows)
+</td>
+</tr>
+<tr>
+<td><b>Windows (PowerShell)</b></td>
+<td>
 
 ```powershell
 irm https://dcr.dexoron.su/install.ps1 | iex
 ```
 
-When executed, both scripts ask whether to:
-- download a prebuilt binary from GitHub Releases
-- or build the project from `git`
+</td>
+</tr>
+<tr>
+<td><b>From source</b></td>
+<td>
 
-Release assets:
-- `dcr-x86_64-unknown-linux-gnu`
-- `dcr-x86_64-apple-darwin`
-- `dcr-aarch64-apple-darwin`
-- `dcr-x86_64-pc-windows-msvc.exe`
+```sh
+git clone https://github.com/dexoron/dcr.git
+cd dcr && cargo build --release
+ln -sf "$PWD/target/release/dcr" ~/.local/bin/dcr
+```
 
-## Update
+</td>
+</tr>
+</table>
 
-- If DCR was installed from GitHub release assets, `install.sh`, `install.ps1`, or built manually:
-  - use `dcr --update`
-- If DCR is installed via `pacman/AUR`:
-  - update with your package manager: `paru/yay -Syu dcr` or `sudo pacman -Syu dcr`
-  - `dcr --update` detects package-managed installs and asks you to update via package manager
+---
 
 ## Quick Start
 
-Create a new project:
-`dcr new hello`
-
-Or initialize the current directory (the directory must be empty):
-`dcr init`
-
-Project structure:
-
-```txt
-hello/
-- src/
-- - main.c
-- dcr.toml
-```
-
-Build and run the project:
-`dcr run` or `dcr run --release`
-
-## Commands
-
-### `dcr new <name>`
-Creates a project with the specified name in the current directory.
-
-### `dcr init`
-Creates a project in the current directory. The project name is taken from the directory name. The directory must be empty.
-
-### `dcr setup`
-Initializes the registry system by reading `~/.dcr/config.toml` and verifying the availability of configured indices.
-
-### `dcr add <name> <source>`
-Adds a dependency to `dcr.toml`.
-If a registry is configured, `dcr` automatically finds the package.
-Git/Path syntax: `path:`, `github:`, `gitlab:`, `git:`, or a full URL.
-Use `--branch`, `--tag`, or `--rev` for Git dependencies.
-
-### `dcr build [profile]`
-Builds the project. If no profile is specified, `--debug` is used.
-Use `--force` to rebuild without cache, `--clean` to clean before build.
-
-### `dcr run [profile]`
-Builds the project and runs the binary. If no profile is specified, `--debug` is used.
-Use `--force` to rebuild without cache, `--clean` to clean before build.
-
-Run manually:
-`./target/<profile>/<name>`
-
-### `dcr clean`
-Removes the `target` directory in the project root.
-Use `dcr clean --all` in a workspace root to clean all member projects.
-
-### `dcr gen`
-Generates IDE integration files and build tools.
-- `dcr gen vscode`: VS Code workspace config
-- `dcr gen clion`: CLion project files
-- `dcr gen compile-commands`: `compile_commands.json` for clang tools
-
-### `dcr test`
-Runs the test suite.
-Use `dcr test --init` to create test files.
-
-## Build Profiles
-Two profiles are supported:
-- `--debug` (default) - built-in flags per compiler
-- `--release` - built-in flags per compiler
-
-Custom flags can be added in `dcr.toml` via `build.cflags` and `build.ldflags`.
-Profile-specific flags can be added via `[build.debug]` and `[build.release]`.
-You can also set `build.target` to override the output directory (profile-independent).
-You can set `build.platform` to pass `-march=<platform>` (GCC/Clang) or `/arch:*` (MSVC) where supported.
-Use `build.kind = "staticlib"` to build a static library instead of a binary.
-Use `build.kind = "sharedlib"` to build a shared library (`.so`/`.dylib`/`.dll`).
-`dcr run` is only for `build.kind = "bin"` and will fail for libraries.
-Use `build.exclude`/`build.include` to control source/header collection.
-Use `build.roots` and `build.src_disable` to replace the default `src/` root.
-Use `build.steps` and `build.post_steps` to run custom commands.
-Use `build.clean` for extra cleanup paths and `[run].cmd` to override run command.
-
-## Cross-compilation
-
-DCR supports cross-compilation via `--target <triple>` or short names:
-
 ```sh
-dcr build --target linux --release    # x86_64-unknown-linux-gnu
-dcr build --target macos --release    # x86_64-apple-darwin
-dcr build --target windows --release  # x86_64-pc-windows-msvc
-dcr run --target aarch64-linux-gnu
+dcr new hello
+cd hello
+dcr run
 ```
 
-Configure multiple targets and target-specific settings in `dcr.toml`:
+**Project structure:**
 
-```toml
-[build.targets]
-targets = ["linux", "windows"]
-
-[build.linux]
-compiler = "gcc"
-cflags = ["-O2"]
-
-[build.windows]
-compiler = "x86_64-w64-mingw32-gcc"
+```
+hello/
+├── dcr.toml       # project config
+└── src/
+    └── main.c
 ```
 
-See [Cross-compilation guide](docs/dependencies-and-build/cross-compilation.md) for details.
+---
 
-## Configuration
-The main project file is `dcr.toml`.
-For multi-registry management, use `~/.dcr/config.toml`.
-
-Example `dcr.toml`:
+## dcr.toml Example
 
 ```toml
 [package]
 name = "hello"
 version = "0.1.0"
-type = "app" # or "lib", "none"
 
 [build]
 language = "c"
 standard = "c11"
 compiler = "clang"
-kind = "bin" # "bin", "staticlib", "sharedlib"
-# Optional platform hint
-# platform = "x86_64"
-# Optional custom flags
-cflags = ["-Wall", "-Wextra"]
-ldflags = ["-lm"]
-#
-# Optional include/exclude:
-# exclude = ["src/vendor", "src/legacy/**"]
-# include = ["src/boot/arch/**"]
-
-[toolchain]
-# Optional tool overrides:
-# cc = "clang"
-# cxx = "clang++"
-# as = "as"
-# ar = "ar"
-# ld = "ld"
-# uic = "uic"
-# moc = "moc"
-# rcc = "rcc"
+kind = "bin"
 
 [dependencies]
-my_lib = "path:./libs/my_lib"
-cool_lib = { git = "https://github.com/user/cool_lib", tag = "v1.0" }
 ```
 
-Workspace example:
-...
-[workspace]
-kernel = { path = "src/kernel", deps = ["core", "userspace"] }
-core = { path = "src/core", deps = ["userspace"] }
-userspace = { path = "src/userspace" }
+---
+
+## Base Commands
+
+| Command | Description |
+|---|---|
+| `dcr new <name>` | Create a new project |
+| `dcr init` | Initialize current directory |
+| `dcr build [--release]` | Build the project |
+| `dcr run [--release]` | Build and run |
+| `dcr clean` | Remove build artifacts |
+
+other in [docs/](docs/) and `dcr --help`
+
+---
+
+## Platforms
+
+<div align="center">
+
+| OS | x86_64 | aarch64 | armv7 | i686 | riscv64 | GNU | Musl | MSVC | MinGW |
+|:---:|:---:|:---:|:---:|:---:|:---:|:---:|:---:|:---:|:---:|
+| Linux   | ✅ | ✅ | ❌ | ❌ | ❌ | ✅ | ✅ | ❌ | ❌ |
+| macOS   | ✅ | ✅ | ❌ | ❌ | ❌ | ❌ | ❌ | ❌ | ❌ |
+| Windows | ✅ | ✅ | ❌ | ❌ | ❌ | ❌ | ❌ | ✅ | ✅ |
+| FreeBSD | ⚠️ | ⚠️ | ❌ | ❌ | ❌ | ⚠️ | ❌ | ❌ | ❌ |
+| OpenBSD | ⚠️ | ⚠️ | ❌ | ❌ | ❌ | ⚠️ | ❌ | ❌ | ❌ |
+| NetBSD  | ⚠️ | ⚠️ | ❌ | ❌ | ❌ | ⚠️ | ❌ | ❌ | ❌ |
+
+✅ officially supported · ⚠️ community / best-effort · ❌ not supported
+
+</div>
+
+---
+
+## Documentation
+
+Full docs at **[dcr.dexoron.su](https://dcr.dexoron.su)** or in the [`docs/`](docs/) directory.
+
+---
+
+## Contributors
+
+<div align="center">
+
+| | Name | Role | GitHub |
+|:---:|---|---|---|
+| 👤 | Dexoron (Bezotechestvo Vladimir) | Maintainer, Creator | [@dexoron](https://github.com/dexoron) |
+| 👤 | Kai | Maintainer | [@peoplemiau1](https://github.com/peoplemiau1) |
+
+</div>
+
+---
+
+## Contributing
+
+See [CONTRIBUTING.md](CONTRIBUTING.md). Before a PR:
+
+```sh
+cargo fmt --all
+cargo clippy --all-targets --all-features -- -D warnings
+cargo test
 ```
 
-Git and Path dependencies are supported. DCR will resolve them on build and generate `dcr.lock`.
+---
 
-Incremental build note: object files are rebuilt when source `.c/.cpp` or included header files change.
+<div align="center">
 
+GPL-3.0 — see [LICENSE](LICENSE)<br/>
+Made with ❤️ by [Dexoron](https://github.com/dexoron) and contributors.
 
-## Requirements
-- Rust toolchain (`rustc`, `cargo`) - for building DCR from source
-- C compiler (`clang`, `gcc`, or 'cl'(msvc))
-
-## Releases
-Releases are built automatically via GitHub Actions (`.github/workflows/release.yml`) when a tag matching `v*` is pushed.
-
-## License
-See `LICENSE`.
+</div>

TODO.md

@@ -57,9 +57,11 @@ Priority list of tasks to turn DCR into a true Cargo killer for C/C++ developers
 ---
 
 **Currently in progress:**
+
 - ...
 
 **Completed in recent releases:**
+
 - Workspaces
 - Cross-compilation
 - IDE config generation (VS Code, CLion, compile_commands.json)

build.rs

@@ -1,3 +1,20 @@
+// 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/>.
+
 fn main() {
     let target = std::env::var("TARGET").unwrap_or_else(|_| "unknown-target".to_string());
     println!("cargo:rustc-env=DCR_TARGET={target}");

docs/SUMMARY.md

@@ -27,6 +27,7 @@
 * [dcr clean](commands/dcr-clean.md)
 * [dcr gen](commands/dcr-gen.md)
 * [dcr test](commands/dcr-test.md)
+* [dcr tree](commands/dcr-tree.md)
 
 ## Dependencies & Build
 

docs/commands/dcr-add.md

@@ -5,11 +5,15 @@ Add a dependency to `dcr.toml`.
 ## Usage
 
 ```bash
-dcr add <name> <source> [options]
+dcr add <name> [source] [options]
 ```
 
+If `<source>` is omitted and a registry is configured, DCR will look up the
+package by name in the registry and add it as a version dependency.
+
 ## Sources
 
+- *omitted*: Look up in the configured registry.
 - `path:./path/to/lib`: Local directory.
 - `github:user/repo`: GitHub repository.
 - `gitlab:user/repo`: GitLab repository.
@@ -29,4 +33,5 @@ dcr add my_lib path:./libs/my_lib
 dcr add cool_lib github:user/cool_lib
 dcr add shared_lib gitlab:org/shared --branch develop
 dcr add custom_lib git:git.internal.com/r/lib --tag v1.0.0
+dcr add mylib                    # Looks up in registry
 ```

docs/commands/dcr-build.md

@@ -25,6 +25,8 @@ dcr build --debug --clean
 ## Config values used
 
 - `package.name`
+- `build.filename`
+- `build.extension`
 - `build.compiler`
 - `build.language`
 - `build.standard`
@@ -33,6 +35,7 @@ dcr build --debug --clean
 - `build.platform`
 - `build.cflags`
 - `build.ldflags`
+- `build.ldscript`
 - `build.debug` / `build.release`
 - `build.exclude`
 - `build.include`
@@ -56,11 +59,16 @@ dcr build --debug --clean
 - Profile flag (`--debug` / `--release`) can appear in any argument position (duplicates are rejected).
 - Unknown profile flags return an error.
 - `--target <triple>` builds for specified target (short names: `linux`, `macos`, `windows`).
+- `--verbose` prints the compiler/linker command lines to stderr (also works via `DCR_DEBUG` env var).
 - If no `--target`, builds for `build.targets` or native.
 - Incremental rebuild checks source/object mtime and tracked header dependencies.
 - `--force` skips build cache checks and recompiles.
 - `--clean` removes `target/<profile>` and `build.clean` paths before building.
+- `build.filename` + `build.extension` allow full control over the final artifact name (e.g. `KERNEL.BIN` instead of using `package.name`). When `build.kind = "efi"`, the output is a PE32+ executable with `.efi` extension.
+- `build.kind = "efi"` links with `-shared -nostdlib -Wl,-dll -Wl,--subsystem,10` for UEFI PE32+ format. Use `build.filename` and `build.extension` for full control over the artifact name.
+- `build.kind = "elf"` produces a bare-metal ELF executable. Linking flags are user-controlled via `build.ldflags` (no PIE/CRT defaults are added).
 - Default GCC/Clang profile flags: `debug` -> `-O0 -g -Wall -Wextra -fno-omit-frame-pointer -DDCR_DEBUG`, `release` -> `-O3 -DNDEBUG`.
+  These defaults are **not applied** for bare-metal targets (e.g. `aarch64-none-elf`, targets containing `none` / `-elf` / `eabi`).
 - For `language = "asm"` with `compiler = "as"`/`"gas"`, use `.s` files (no preprocessing). For `.S`, use `gcc` or `clang`.
 - In workspace root, `dcr build` builds all members in dependency order.
 - `build.exclude` removes paths from source/header collection; `build.include` re-allows matching paths and has priority over `exclude`.

docs/commands/dcr-clean.md

@@ -15,7 +15,7 @@ dcr clean --release --all
 ## Behavior
 
 - Without arguments: removes entire `target/`.
-- With profile: removes only `target/<profile>/`.
+- With profile: removes only the profile-specific directory. Respects `build.target` from config: if `build.target = "aarch64-unknown-linux-gnu"`, cleans `target/aarch64-unknown-linux-gnu/<profile>/`.
 - With `--all`: also cleans all workspace members.
 - Additionally removes paths from `build.clean` if configured.
 - `build.clean` supports `{profile}` and version placeholders.

docs/commands/dcr-run.md

@@ -23,7 +23,7 @@ dcr run --debug --clean
 
 ## Restrictions
 
-- If `build.kind = "staticlib"` or `build.kind = "sharedlib"`, `run` exits with error.
+- If `build.kind` (or `build.{profile}.kind`) is `"staticlib"` or `"sharedlib"`, `run` exits with error.
 - The profile is selected from the first argument.
 - `--target <triple>` runs the binary for specified target (short names: `linux`, `macos`, `windows`).
 - `--force` skips build cache checks and recompiles.

docs/commands/dcr-test.md

@@ -6,6 +6,7 @@ Runs the project's test suite.
 
 ```sh
 dcr test
+dcr test --debug
 dcr test --release
 dcr test --target linux
 dcr test --init
@@ -39,6 +40,6 @@ DCR uses a simple test framework:
 
 - Test binary is linked with the main project (for lib projects) or standalone.
 - `--init` creates `tests/dcr_test.h` and `tests/test.c` if missing.
-- Tests run in release mode by default for performance.
+- Tests run in debug mode by default. Use `--release` for release mode.
 - Custom test logic can be added by editing `tests/test.c`.
 - Fails if no `tests/test.c` exists (run `dcr test --init` first).

docs/commands/dcr-tree.md

@@ -0,0 +1,22 @@
+# dcr tree
+
+Displays a visual dependency tree for the current project (similar to `cargo tree`).
+
+## Usage
+
+```sh
+dcr tree
+dcr tree --invert
+dcr tree -p some-package
+```
+
+## What it shows
+
+- All direct and transitive dependencies
+- Version of each dependency
+- Whether a dependency is a registry, git, or path dependency
+
+## Notes
+
+- Useful for debugging dependency issues and understanding the build graph.
+- Output format is inspired by `cargo tree`.

docs/configuration/build-section.md

@@ -8,6 +8,8 @@ language = "c"
 standard = "c11"
 compiler = "clang"
 kind = "bin"
+# filename = "KERNEL"
+# extension = "BIN"
 # optional:
 # inherit = true  # Inherit from base (default true)
 # targets = ["linux", "macos"]  # Multiple targets to build
@@ -29,15 +31,23 @@ kind = "bin"
 
 - `language` (string or array, required): `c`, `c++`, `cpp`, `cxx`, or `asm`.
   Mixed languages can be specified as an array, for example `["c", "c++", "asm"]`.
-- `standard` (string, required): language standard passed to compiler.
+- `standard` (string, required): C language standard passed to compiler (e.g. `c11`, `c17`, `gnu11`).
+- `cxx_standard` (string, optional): C++ language standard passed to compiler for `.cpp`/`.cxx`/`.cc` files
+  (e.g. `c++17`, `gnu++17`, `c++20`). When set, overrides `standard` for C++ sources.
 - `compiler` (string, required): compiler command (for example `clang`, `gcc`, `cl`).
-- `kind` (string, required): `bin`, `staticlib`, or `sharedlib`.
+- `kind` (string, required): `bin`, `staticlib`, `sharedlib`, `efi`, or `elf`.
+- `filename` (string, optional): custom output filename (without extension). Overrides `package.name` for the final artifact.
+- `extension` (string, optional): custom file extension without the leading dot (e.g. `BIN`, `efi`, `EFI`). Combined with `filename`.
 - `inherit` (bool, optional): inherit settings from base `[build]` (default `true`). If `false`, only use target/profile specific settings.
 - `targets` (string array, optional): list of targets to build simultaneously. Supports short names (`linux`, `macos`, `windows`).
 - `target` (string, optional): custom output directory for final artifact.
+  When set, DCR automatically injects `--target=<value>` into `cflags` (useful for clang cross-compilation).
 - `platform` (string, optional): architecture hint for compiler (used for `-march` or `/arch`).
 - `cflags` (string array, optional): extra compile flags.
+  Supports variable substitution — see [Variable substitution](#variable-substitution) below.
 - `ldflags` (string array, optional): extra link flags.
+  Supports variable substitution — see [Variable substitution](#variable-substitution) below.
+- `ldscript` (string, optional): linker script path. Passed as `-T <path>` to the linker. Useful for bare-metal/embedded/freestanding targets.
 - `exclude` (string array, optional): paths or glob patterns to skip during source/header collection.
 - `include` (string array, optional): allowlist paths or globs that override `exclude`.
 - `include` directory entries (non-glob) are also passed to the compiler as `-I` include paths.
@@ -54,9 +64,30 @@ Notes for `exclude`/`include`:
 - Use `include` to re-allow nested paths, for example exclude `src/boot` but allow `src/boot/arch/**`.
 When using glob patterns in `exclude`, DCR converts them internally, so `exclude` globs still work as expected.
 
-### Build steps
+### Variable substitution
 
-Build steps run shell commands before compilation. Post steps run after linking.
+`cflags`, `ldflags`, and `include` directory entries support the same `{placeholder}` variables
+as build/post steps:
+
+| Variable | Description |
+|---|---|
+| `{profile}` | Build profile (`debug` / `release`) |
+| `{name}` | Package name |
+| `{version}` | Full package version (e.g. `0.2.1`) |
+| `{version_major}` | Major version number |
+| `{version_minor}` | Minor version number |
+| `{version_patch}` | Patch version number |
+| `{version_suffix}` | Version suffix (e.g. `-rc1`) |
+| `{version_suffix_dash}` | Suffix with leading dash (or empty) |
+
+Example:
+
+```toml
+[build]
+cflags = ['-DPROJECT_VERSION="{version}"', '-DVERSION_MAJOR={version_major}']
+```
+
+## Build steps
 
 ```toml
 [[build.steps]]
@@ -145,4 +176,4 @@ rcc = "rcc"
 
 - Compiler backend is selected by compiler string (`gcc`, `clang`, `cl`, `clang-cl`).
 - Empty or unknown compiler value falls back to clang-like build path.
-- `run` is not allowed for library kinds (`staticlib`, `sharedlib`).
+- `run` is not allowed for library kinds (`staticlib`, `sharedlib`), `efi`, or `elf`.

docs/configuration/package-section.md

@@ -4,9 +4,12 @@
 
 ```toml
 [package]
-name = "my-app"
-version = "0.1.0"
-type = "app"
+name        = "my-app"
+version     = "0.1.0"
+type        = "app"
+description = "My application"
+author      = "John Doe"
+license     = "MIT"
 ```
 
 ## Fields
@@ -14,6 +17,15 @@ type = "app"
 - `name` (string, required): used as output artifact base name.
 - `version` (string, required): used in `dcr.lock` project entry.
 - `type` (string, optional): project type (`app`, `lib`, `none`).
+- `description` (string, optional): human-readable project description.
+- `author` (string, optional): single author name.
+- `authors` (array of strings, optional): list of authors.
+- `license` (string, optional): project license identifier (e.g. `MIT`, `GPL-3.0-or-later`).
+- `homepage` (string, optional): project homepage URL.
+- `repository` (string, optional): source repository URL.
+- `readme` (string, optional): path to README file.
+- `keywords` (array of strings, optional): project keywords.
+- `categories` (array of strings, optional): project categories.
 
 ## Notes
 

docs/dependencies-and-build/cross-compilation.md

@@ -178,6 +178,8 @@ compiler = "aarch64-linux-gnu-gcc"' >> dcr.toml
 dcr build --target aarch64-linux-gnu --release
 ```
 
+**Note:** If you set `target = "aarch64-linux-gnu"` (or any value) directly under `[build]`, DCR will automatically add `--target=...` to cflags when using clang. You usually don't need to repeat it manually.
+
 ### Windows Build on Linux
 
 ```bash

docs/getting-started/build-and-run.md

@@ -49,7 +49,7 @@ dcr clean --release --all
 
 ## Notes
 
-- `run` is unavailable for `build.kind = "staticlib"` and `build.kind = "sharedlib"`.
+- `run` is unavailable for `build.kind = "staticlib"`, `build.kind = "sharedlib"`, `build.kind = "efi"`, and `build.kind = "elf"`.
 - Build profile flag (`--debug` / `--release`) can be passed in any argument position.
 - Unknown profile flags produce an error.
 - In workspace root, `clean --all` cleans all member projects.

docs/reference-and-help/cli-reference.md

@@ -7,9 +7,11 @@ dcr new <name>
 dcr init
 dcr setup
 dcr add <name> <source>(optional)
-dcr build [--debug|--release]
+dcr build [--debug|--release] [--target <triple>]
 dcr run [--debug|--release]
 dcr clean [--debug|--release] [--all]
+dcr tree
+dcr test
 dcr gen <subcommand>
 dcr --help
 dcr --version
@@ -18,11 +20,13 @@ dcr --update
 
 ## Notes on argument parsing
 
-- `build`/`run` parse flags in any order (`--debug|--release`, `--force`, `--clean`) and reject duplicates.
+- `build`/`run` parse flags in any order (`--debug|--release`, `--force`, `--clean`, `--verbose`) and reject duplicates.
 - `new` requires exactly one argument.
 - `init` and `--update` do not accept extra arguments.
 - `clean` accepts `--debug|--release` and optional `--all`.
 - `gen` supports `project-info`, `compile-commands`, `vscode`, `clion`.
+- `tree` shows a dependency tree (similar to `cargo tree`).
+- `test` / `tests` runs the project's tests.
 
 ## Exit behavior overview
 

docs/reference-and-help/config-reference.md

@@ -4,85 +4,131 @@
 
 ```toml
 [package]
-name = "string"      # required
-version = "string"   # required
+name        = "string"            # required
+version     = "string"            # required
+type        = "string"            # optional: "app", "lib", "none"
+description = "string"            # optional
+author      = "string"            # optional
+authors     = ["string", "..."]   # optional
+license     = "string"            # optional
+homepage    = "string"            # optional
+repository  = "string"            # optional
+readme      = "string"            # optional
+keywords    = ["string", "..."]   # optional
+categories  = ["string", "..."]   # optional
 
 [build]
-language = "c|c++|cpp|cxx|asm"     # required (string or array)
-standard = "string"            # required
-compiler = "string"            # required
-kind = "bin|staticlib|sharedlib"         # required
-target = "string"              # optional
-platform = "string"            # optional
-cflags = ["string", "..."]     # optional
-ldflags = ["string", "..."]    # optional
-exclude = ["string", "..."]    # optional
-include = ["string", "..."]    # optional
-roots = ["string", "..."]      # optional
-src_disable = false            # optional
-pkg_config = ["string", "..."] # optional
-generated = ["string", "..."]  # optional
-expect = ["string", "..."]     # optional
-clean = ["string", "..."]      # optional
+language     = "c|c++|cpp|cxx|asm"               # required (string or array)
+standard     = "string"                          # required (e.g. "c11", "gnu11")
+cxx_standard = "string"                          # optional (e.g. "c++17", "gnu++17")
+compiler     = "string"                          # required (e.g. "clang", "gcc")
+kind         = "bin|staticlib|sharedlib|efi|elf" # required
+target       = "string"                          # optional (cross-compilation target triple)
+platform     = "string"                          # optional (architecture hint, -march)
+type         = "string"                          # optional
+cflags       = ["string", "..."]                 # optional (supports {version} etc.)
+ldflags      = ["string", "..."]                 # optional (supports {version} etc.)
+ldscript     = "string"                          # optional (linker script path)
+exclude      = ["string", "..."]                 # optional (glob patterns)
+include      = ["string", "..."]                 # optional (allowlist + -I dirs)
+roots        = ["string", "..."]                 # optional (source roots)
+src_disable  = false                             # optional (disable default src/)
+pkg_config   = ["string", "..."]                 # optional (pkg-config packages)
+generated    = ["string", "..."]                 # optional (generated file patterns)
+expect       = ["string", "..."]                 # optional (expected artifact patterns)
+clean        = ["string", "..."]                 # optional (extra clean paths)
+targets      = ["string", "..."]                 # optional (build targets)
+filename     = "string"                          # optional (custom output name)
+extension    = "string"                          # optional (custom extension)
+inherit      = true                              # optional (inherit base settings)
 
 [[build.steps]]
-name = "string"
-in = "glob"
-out = "path or glob"
-cmd = "string"
+name = "string"    # required
+in   = "glob"      # required
+out  = "path"      # required
+cmd  = "string"    # required
+
+# Inline steps (equivalent to [[build.steps]])
+steps = [
+  { name = "string", in = "glob", out = "path", cmd = "string" },
+]
 
 [[build.post_steps]]
-name = "string"
-in = "glob"
-out = "path or glob"
-cmd = "string"
+name = "string"    # required
+in   = "glob"      # required (or "target/...")
+out  = "path"      # required
+cmd  = "string"    # required
 
-# Inline array form (equivalent to [[build.steps]] / [[build.post_steps]])
-steps = [
-  { name = "string", in = "glob", out = "path or glob", cmd = "string" },
-]
+# Inline post_steps (equivalent to [[build.post_steps]])
 post_steps = [
-    { name = "string", in = "glob", out = "path or glob", cmd = "string" },
+  { name = "string", in = "glob", out = "path", cmd = "string" },
 ]
 
+# Profile overrides (inherit all from [build])
 [build.debug]
-cflags = ["string", "..."]     # optional
-ldflags = ["string", "..."]    # optional
+cflags  = ["string", "..."]  # optional
+ldflags = ["string", "..."]  # optional
 
 [build.release]
-cflags = ["string", "..."]     # optional
-ldflags = ["string", "..."]    # optional
+cflags  = ["string", "..."]  # optional
+ldflags = ["string", "..."]  # optional
+
+# Target-specific overrides
+[build.linux]
+compiler = "string"
+cflags   = ["string", "..."]
+
+[build.windows]
+compiler = "string"
+
+# Target + profile override
+[build.linux.release]
+cflags = ["string", "..."]
 
 [toolchain]
-cc = "string"   # optional
-cxx = "string"  # optional
-as = "string"   # optional
-ar = "string"   # optional
-ld = "string"   # optional
-uic = "string"  # optional
-moc = "string"  # optional
-rcc = "string"  # optional
+cc  = "string"  # optional (C compiler override)
+cxx = "string"  # optional (C++ compiler override)
+as  = "string"  # optional (assembler override)
+ar  = "string"  # optional (archiver override)
+ld  = "string"  # optional (linker override)
+uic = "string"  # optional (Qt uic)
+moc = "string"  # optional (Qt moc)
+rcc = "string"  # optional (Qt rcc)
 
 [run]
-cmd = "string"  # optional
+cmd = "string"  # required for `dcr run`
+
+# Debug run variant
+[run.debug]
+cmd = "string"
 
 [workspace]
-name = { path = "string", deps = ["string", "..."] }
+[workspace.member_name]
+path = "string"             # required
+deps = ["string", "..."]    # optional
 
 [dependencies]
-name = {
-  path = "string",              # required for each dependency
-  include = ["string", "..."],  # optional
-  lib = ["string", "..."],      # optional
-  libs = ["string", "..."],     # optional
-}
+[dependencies.dep_name]
+path    = "string"          # local path
+# or
+version = "string"          # registry version
+# or
+git     = "string"          # git URL
+branch  = "string"          # optional (git branch)
+tag     = "string"          # optional (git tag)
+rev     = "string"          # optional (git commit)
+# common fields:
+include = ["string", "..."] # optional (include dirs)
+lib     = ["string", "..."] # optional (lib dirs)
+libs    = ["string", "..."] # optional (link libs)
+features = ["string", "..."] # optional (registry features)
 ```
 
 ## Validation rules
 
 - `[package]`, `[build]`, `[dependencies]` must exist.
 - Required string fields must be non-empty.
-- `build.kind` must be `bin`, `staticlib`, or `sharedlib`.
+- `build.kind` must be `bin`, `staticlib`, `sharedlib`, `efi`, or `elf`.
 - Dependency fields `include/lib/libs` must be string arrays when provided.
 - `build.exclude`/`build.include` must be string arrays when provided.
 - `build.roots` must be a string array when provided.

install.sh

@@ -61,7 +61,7 @@ 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
+    read -r -p "Enter 1 or 2 [1]: " choice < /dev/tty
 
     case "${choice:-1}" in
         1) CHANNEL="stable" ;;
@@ -74,7 +74,7 @@ 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
+    read -r -p "Enter 1 or 2 [1]: " choice < /dev/tty
 
     case "${choice:-1}" in
         1) INSTALL_MODE="release" ;;
@@ -215,4 +215,4 @@ main() {
     log "Log saved to $LOGFILE"
 }
 
-main "$@"
+main "$@"

packaging/snap/snapcraft.yaml

@@ -0,0 +1,18 @@
+name: dcr
+base: core22
+version: '0.6.9'
+summary: Cargo-like utility to manage C/C++ projects
+description: |
+  A build tool and package manager for C/C++ projects inspired by Rust's Cargo.
+
+grade: stable
+confinement: classic
+
+apps:
+  dcr:
+    command: bin/dcr
+
+parts:
+  dcr:
+    plugin: dump
+    source: dist/

src/cli/add.rs

@@ -1,4 +1,22 @@
+// 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::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};
@@ -12,6 +30,7 @@ pub struct AddArgs {
     pub branch: Option<String>,
     pub tag: Option<String>,
     pub rev: Option<String>,
+    pub version_from_registry: Option<String>,
 }
 
 pub fn add(args: &[String]) -> i32 {
@@ -71,6 +90,8 @@ pub fn add(args: &[String]) -> i32 {
         let mut table = Map::new();
         table.insert("path".to_string(), Value::String(path));
         Value::Table(table)
+    } else if let Some(version) = add_args.version_from_registry {
+        Value::String(version)
     } else {
         error("Dependency source (path or git) must be provided");
         return 1;
@@ -124,8 +145,38 @@ fn parse_add_args(args: &[String]) -> Result<AddArgs, i32> {
         }
         source_spec = s.clone();
     } else {
-        error("Dependency source is required");
-        return Err(1);
+        // No source provided — try registry auto-lookup
+        match register::resolve_package_from_registry(&name) {
+            Ok(info) => {
+                let version = info
+                    .get("latest_version")
+                    .or_else(|| info.get("version"))
+                    .and_then(|v| v.as_str())
+                    .ok_or_else(|| {
+                        (
+                            "Registry entry for `".to_string() + &name + "` has no version field",
+                            1,
+                        )
+                    })
+                    .map_err(|(msg, code)| {
+                        error(&msg);
+                        code
+                    })?;
+                return Ok(AddArgs {
+                    name,
+                    path: None,
+                    git: None,
+                    branch: None,
+                    tag: None,
+                    rev: None,
+                    version_from_registry: Some(version.to_string()),
+                });
+            }
+            Err(e) => {
+                error(&format!("Cannot add `{}` without source: {}", name, e));
+                return Err(1);
+            }
+        }
     }
 
     while let Some(arg) = iter.next() {
@@ -197,5 +248,6 @@ fn parse_add_args(args: &[String]) -> Result<AddArgs, i32> {
         branch,
         tag,
         rev,
+        version_from_registry: None,
     })
 }

src/cli/build.rs

@@ -1,3 +1,20 @@
+// 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::cli::clean::clean;
 use crate::cli::flags::parse_build_run_flags;
 use crate::core::builder::common;
@@ -50,7 +67,17 @@ pub fn build(args: &[String]) -> i32 {
         Err(code) => return code,
     };
 
-    // If no target specified, use default host target for target-specific config
+    if flags.target.is_none() {
+        let config_path = root.join("dcr.toml");
+        if let Ok(config) = Config::open(config_path.to_str().unwrap())
+            && !config.is_workspace_only()
+        {
+            let bt = get_build_string_with_profile(&config, "target", "debug");
+            if !bt.is_empty() {
+                flags.target = Some(bt);
+            }
+        }
+    }
     if flags.target.is_none() {
         let default_target = if cfg!(target_os = "linux") {
             "x86_64-unknown-linux-gnu"
@@ -69,7 +96,14 @@ pub fn build(args: &[String]) -> i32 {
         let _ = clean(&clean_args);
     }
     match with_dir(&root, || {
-        build_from_root(&root, &flags.profile, flags.target.as_deref(), flags.force)
+        build_from_root(
+            &root,
+            &flags.profile,
+            flags.target.as_deref(),
+            flags.force,
+            flags.verbose,
+            flags.workspace.as_deref(),
+        )
     }) {
         Ok(()) => 0,
         Err(msg) => {
@@ -199,11 +233,18 @@ fn get_list_with_profile_and_target(
     // Custom from target/profile
     if let Some(val) = get_config_value_raw(config, "build", field, profile, target) {
         if let Some(_arr) = val.as_array() {
-            let custom = parse_string_array(&val, &format!("build.{field}"))?;
-            if inherit {
-                out.extend(custom);
-            } else {
-                out = custom;
+            let is_base = inherit
+                && config
+                    .get(&format!("build.{field}"))
+                    .map(|v| v == &val)
+                    .unwrap_or(false);
+            if !is_base {
+                let custom = parse_string_array(&val, &format!("build.{field}"))?;
+                if inherit {
+                    out.extend(custom);
+                } else {
+                    out = custom;
+                }
             }
         }
     } else if inherit {
@@ -334,16 +375,27 @@ fn get_build_steps_with_profile(
     get_build_steps(config, &format!("build.{field}"))
 }
 
-fn ensure_target_dirs(items: &[String], profile: &str, target_dir: Option<String>) {
-    if !items.contains(&"target".to_string()) {
+fn ensure_target_dirs(
+    items: &[String],
+    profile: &str,
+    target_dir: Option<String>,
+    skip_local_target: bool,
+) {
+    if !skip_local_target && !items.contains(&"target".to_string()) {
         let _ = fs::create_dir("./target");
     }
     if let Some(dir) = &target_dir {
         let _ = fs::create_dir_all(dir);
     } else {
+        let default_dir = if cfg!(target_os = "linux") {
+            let arch = std::env::consts::ARCH;
+            format!("{arch}-unknown-linux-gnu/{profile}")
+        } else {
+            profile.to_string()
+        };
         let target_items = check_dir(Some("target")).unwrap_or_default();
-        if !target_items.contains(&profile.to_string()) {
-            let _ = fs::create_dir(format!("./target/{profile}"));
+        if !target_items.contains(&default_dir) {
+            let _ = fs::create_dir_all(format!("./target/{default_dir}"));
         }
     }
 }
@@ -369,8 +421,39 @@ fn build_from_root(
     profile: &str,
     target: Option<&str>,
     force: bool,
+    verbose: bool,
+    workspace: Option<&str>,
 ) -> Result<(), String> {
     let config = Config::open("./dcr.toml").map_err(|err| err.to_string())?;
+
+    if config.is_workspace_only() {
+        let ws = parse_workspace(&config, profile, target, root)?
+            .ok_or_else(|| "Workspace root has no members defined".to_string())?;
+        let members: Vec<_> = if let Some(filter_name) = workspace {
+            ws.members
+                .into_iter()
+                .filter(|m| m.name == filter_name)
+                .collect()
+        } else {
+            ws.members
+        };
+        if members.is_empty() {
+            return Err("No matching workspace members to build".to_string());
+        }
+        for member in &members {
+            build_project_at(
+                &member.path,
+                profile,
+                target,
+                &[],
+                force,
+                verbose,
+                Some(root),
+            )?;
+        }
+        return Ok(());
+    }
+
     let project_name = get_config_str(&config, "package.name");
     let project_version = get_config_str(&config, "package.version");
 
@@ -409,13 +492,50 @@ fn build_from_root(
                 )
             );
         }
-        if let Some(workspace) = parse_workspace(&config, profile, build_target.as_deref(), root)? {
-            build_workspace(&workspace, profile, build_target.as_deref(), force)?;
-            let excludes: Vec<std::path::PathBuf> =
-                workspace.members.iter().map(|m| m.path.clone()).collect();
-            build_project_at(root, profile, build_target.as_deref(), &excludes, force)?;
+        if let Some(ws) = parse_workspace(&config, profile, build_target.as_deref(), root)? {
+            if let Some(filter_name) = workspace {
+                for member in ws.members.iter().filter(|m| m.name == filter_name) {
+                    build_project_at(
+                        &member.path,
+                        profile,
+                        build_target.as_deref(),
+                        &[],
+                        force,
+                        verbose,
+                        Some(root),
+                    )?;
+                }
+            } else {
+                build_workspace(
+                    &ws,
+                    profile,
+                    build_target.as_deref(),
+                    force,
+                    verbose,
+                    Some(root),
+                )?;
+                let excludes: Vec<std::path::PathBuf> =
+                    ws.members.iter().map(|m| m.path.clone()).collect();
+                build_project_at(
+                    root,
+                    profile,
+                    build_target.as_deref(),
+                    &excludes,
+                    force,
+                    verbose,
+                    None,
+                )?;
+            }
         } else {
-            build_project_at(root, profile, build_target.as_deref(), &[], force)?;
+            build_project_at(
+                root,
+                profile,
+                build_target.as_deref(),
+                &[],
+                force,
+                verbose,
+                None,
+            )?;
         }
     }
     let elapsed = ((start_time.elapsed().as_secs_f64() * 100.0).trunc()) / 100.0;
@@ -432,9 +552,19 @@ fn build_workspace(
     profile: &str,
     target: Option<&str>,
     force: bool,
+    verbose: bool,
+    workspace_root: Option<&Path>,
 ) -> Result<(), String> {
     for member in &workspace.members {
-        build_project_at(&member.path, profile, target, &[], force)?;
+        build_project_at(
+            &member.path,
+            profile,
+            target,
+            &[],
+            force,
+            verbose,
+            workspace_root,
+        )?;
     }
     Ok(())
 }
@@ -445,6 +575,8 @@ fn build_project_at(
     target: Option<&str>,
     exclude_dirs: &[std::path::PathBuf],
     force: bool,
+    verbose: bool,
+    workspace_root: Option<&Path>,
 ) -> Result<(), String> {
     with_dir(project_root, || {
         check_interrupted()?;
@@ -452,7 +584,22 @@ fn build_project_at(
         if !items.contains(&"dcr.toml".to_string()) {
             return Err("dcr.toml file not found".to_string());
         }
-        let config = Config::open("./dcr.toml").map_err(|err| err.to_string())?;
+        let mut config = Config::open("./dcr.toml").map_err(|err| err.to_string())?;
+        // Inherit build fields from workspace root if configured
+        if let Some(root) = workspace_root {
+            let has_inherit = config
+                .get("build.inherit")
+                .and_then(|v| v.as_bool())
+                .unwrap_or(false);
+            if has_inherit {
+                let root_path = root.join("dcr.toml");
+                if root_path.is_file() {
+                    let parent_config =
+                        Config::open(&root_path.to_string_lossy()).map_err(|e| e.to_string())?;
+                    config.merge_parent(&parent_config);
+                }
+            }
+        }
         let project_name = get_config_str(&config, "package.name");
         let project_version = get_config_str(&config, "package.version");
         let build_target_config = get_build_string_with_profile(&config, "target", profile);
@@ -466,6 +613,8 @@ fn build_project_at(
         let build_language = get_language_with_profile(&config, profile)?;
         let build_standard =
             get_string_with_profile_and_target(&config, "standard", profile, build_target);
+        let build_cxx_standard =
+            get_string_with_profile_and_target(&config, "cxx_standard", profile, build_target);
         let build_kind = get_string_with_profile_and_target(&config, "kind", profile, build_target);
         let build_platform =
             get_string_with_profile_and_target(&config, "platform", profile, build_target);
@@ -490,10 +639,21 @@ fn build_project_at(
             .or_else(|| get_config_opt(&config, "toolchain.moc"));
         let tc_rcc = get_config_value(&config, "toolchain", "rcc", profile, build_target)
             .or_else(|| get_config_opt(&config, "toolchain.rcc"));
-        let build_cflags =
+        let mut build_cflags =
             get_list_with_profile_and_target(&config, "cflags", profile, build_target)?;
-        let build_ldflags =
+        let mut build_ldflags =
             get_list_with_profile_and_target(&config, "ldflags", profile, build_target)?;
+        let build_ldscript =
+            get_string_with_profile_and_target(&config, "ldscript", profile, build_target);
+        if !build_ldscript.is_empty() {
+            build_ldflags.push(format!("-T{}", build_ldscript));
+        }
+
+        // Новые поля: filename и extension
+        let output_filename =
+            get_string_with_profile_and_target(&config, "filename", profile, build_target);
+        let output_extension =
+            get_string_with_profile_and_target(&config, "extension", profile, build_target);
         let build_excludes =
             get_list_with_profile_and_target(&config, "exclude", profile, build_target)?;
         let build_includes =
@@ -517,11 +677,48 @@ fn build_project_at(
             tc_cxx.as_deref(),
             tc_as.as_deref(),
         );
+        if let Some(t) = build_target
+            && !t.trim().is_empty()
+            && resolved_compiler.to_lowercase().contains("clang")
+        {
+            let target_flag = format!("--target={}", t.trim());
+            if !build_cflags
+                .iter()
+                .any(|f| f == &target_flag || f.starts_with("--target="))
+            {
+                build_cflags.insert(0, target_flag);
+            }
+        }
         let resolved_linker = resolve_tool("DCR_LD", tc_ld.as_deref());
         let resolved_archiver = resolve_tool("DCR_AR", tc_ar.as_deref());
 
-        let target_dir = build_target.map(|t| format!("target/{t}/{profile}"));
-        ensure_target_dirs(&items, profile, target_dir);
+        let target_dir_binding = match workspace_root {
+            Some(root) => {
+                let target_str = build_target
+                    .map(normalize_target_os)
+                    .filter(|t| !t.is_empty());
+                let rel: PathBuf = match target_str {
+                    Some(ref t) => Path::new("target").join(t).join(profile),
+                    None => {
+                        let default_dir = if cfg!(target_os = "linux") {
+                            let arch = std::env::consts::ARCH;
+                            format!("{arch}-unknown-linux-gnu/{profile}")
+                        } else {
+                            profile.to_string()
+                        };
+                        Path::new("target").join(&default_dir)
+                    }
+                };
+                root.join(&rel).to_string_lossy().to_string()
+            }
+            None => normalize_target(build_target.unwrap_or(""), profile).unwrap_or_default(),
+        };
+        let target_dir = if target_dir_binding.is_empty() {
+            None
+        } else {
+            Some(target_dir_binding.clone())
+        };
+        ensure_target_dirs(&items, profile, target_dir, workspace_root.is_some());
 
         let deps_table = config.get("dependencies").and_then(|v| v.as_table());
         let resolved = resolve_deps(&config, profile, build_target, project_root)?;
@@ -557,7 +754,15 @@ fn build_project_at(
                                 dep_root.display()
                             ));
                         }
-                        build_project_at(&dep_root, profile, build_target, &[], force)?;
+                        build_project_at(
+                            &dep_root,
+                            profile,
+                            build_target,
+                            &[],
+                            force,
+                            verbose,
+                            None,
+                        )?;
                         print!(
                             "\r{:100}\r       {} {} v{}",
                             "",
@@ -646,15 +851,35 @@ fn build_project_at(
             }
         }
 
-        let target_dir_binding = normalize_target(build_target.unwrap_or(""), profile);
+        let version_info = parse_version_info(&project_version);
+        let substitute = |s: &str| -> String {
+            s.replace("{profile}", profile)
+                .replace("{name}", &project_name)
+                .replace("{version}", &version_info.full)
+                .replace("{version_major}", &version_info.major)
+                .replace("{version_minor}", &version_info.minor)
+                .replace("{version_patch}", &version_info.patch)
+                .replace("{version_suffix}", &version_info.suffix)
+                .replace("{version_suffix_dash}", &version_info.suffix_dash)
+        };
+        let resolved_cflags: Vec<String> = resolved_cflags.iter().map(|f| substitute(f)).collect();
+        let modified_ldflags: Vec<String> =
+            resolved_ldflags.iter().map(|f| substitute(f)).collect();
+        let merged_include_dirs: Vec<String> =
+            merged_include_dirs.iter().map(|f| substitute(f)).collect();
         let ctx = BuildContext {
             profile,
             project_name: &project_name,
             compiler: &resolved_compiler,
             language: &build_language,
             standard: &build_standard,
+            cxx_standard: &build_cxx_standard,
             target: build_target,
-            target_dir: target_dir_binding.as_deref(),
+            target_dir: if target_dir_binding.is_empty() {
+                None
+            } else {
+                Some(target_dir_binding.as_str())
+            },
             kind: normalize_kind(&build_kind),
             platform: normalize_platform(&build_platform),
             linker: resolved_linker.as_deref(),
@@ -671,7 +896,18 @@ fn build_project_at(
             lib_dirs: &resolved.lib_dirs,
             libs: &resolved.libs,
             cflags: &resolved_cflags,
-            ldflags: &resolved_ldflags,
+            ldflags: &modified_ldflags,
+            output_filename: if output_filename.is_empty() {
+                None
+            } else {
+                Some(output_filename.as_str())
+            },
+            output_extension: if output_extension.is_empty() {
+                None
+            } else {
+                Some(output_extension.as_str())
+            },
+            verbose,
         };
         if std::env::var("DCR_DEBUG").is_ok() {
             eprintln!("[dcr] debug: compiler={}", ctx.compiler);
@@ -683,7 +919,6 @@ fn build_project_at(
         let tool_execs = resolve_toolchain_execs(&tc_uic, &tc_moc, &tc_rcc, &pkg_configs);
         let step_flags =
             build_step_flags(&resolved_cflags, &resolved.include_dirs, &resolved_compiler);
-        let version_info = parse_version_info(&project_version);
         let step_vars = StepVars {
             profile,
             version: &version_info.full,
@@ -1260,18 +1495,35 @@ fn write_build_fingerprint(ctx: &BuildContext, fingerprint: &str) -> Result<(),
 }
 
 fn build_cache_path(profile: &str, target_dir: Option<&str>) -> std::path::PathBuf {
-    let _ = target_dir;
-    Path::new("./target").join(profile).join(".dcr-build.hash")
+    match target_dir {
+        Some(dir) => Path::new(dir).join(".dcr-build.hash"),
+        None => Path::new("./target").join(profile).join(".dcr-build.hash"),
+    }
 }
 
 fn build_output_path(ctx: &BuildContext) -> String {
+    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)
+    };
+
     if ctx.kind == "staticlib" {
-        return crate::platform::lib_path(ctx.profile, ctx.project_name, ctx.target_dir);
+        return crate::platform::lib_path(ctx.profile, &final_name, ctx.target_dir);
     }
     if ctx.kind == "sharedlib" {
-        return crate::platform::shared_lib_path(ctx.profile, ctx.project_name, ctx.target_dir);
+        return crate::platform::shared_lib_path(ctx.profile, &final_name, ctx.target_dir);
     }
-    crate::platform::bin_path(ctx.profile, ctx.project_name, ctx.target_dir)
+    if ctx.kind == "efi" {
+        return crate::platform::efi_path(ctx.profile, &final_name, ctx.target_dir);
+    }
+    if ctx.kind == "elf" {
+        return crate::platform::elf_path(ctx.profile, &final_name, ctx.target_dir);
+    }
+    crate::platform::bin_path(ctx.profile, &final_name, ctx.target_dir)
 }
 
 fn collect_header_files(

src/cli/clean.rs

@@ -1,3 +1,20 @@
+// 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::config::flags;
 use crate::core::config::Config;
 use crate::core::workspace::parse_workspace;
@@ -91,17 +108,27 @@ fn parse_clean_flags(args: &[String]) -> Result<CleanFlags, String> {
 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.target.clone().or_else(|| {
-        Some(if cfg!(target_os = "linux") {
-            "x86_64-unknown-linux-gnu".to_string()
-        } 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 {
-            "unknown".to_string()
+    let target = flags
+        .target
+        .clone()
+        .or_else(|| {
+            config
+                .get("build.target")
+                .and_then(|v| v.as_str())
+                .map(|s| s.trim().to_string())
+                .filter(|s| !s.is_empty())
         })
-    });
+        .or_else(|| {
+            Some(if cfg!(target_os = "linux") {
+                "x86_64-unknown-linux-gnu".to_string()
+            } 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 {
+                "unknown".to_string()
+            })
+        });
 
     if flags.all
         && let Some(workspace) = parse_workspace(

src/cli/flag_update.rs

@@ -1,3 +1,20 @@
+// 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::utils::log::{error, warn};
 use reqwest::blocking::Client;
 use serde::Deserialize;
@@ -138,8 +155,8 @@ fn download_asset(client: &Client, url: &str) -> Result<Vec<u8>, String> {
 fn asset_candidates(target: &str) -> Vec<String> {
     let mut names = vec![format!("dcr-{target}")];
 
-    if target == "x86_64-pc-windows-msvc" {
-        names.push("dcr-x86_64-pc-windows-msvc.exe".to_string());
+    if target.contains("-windows-") || target.ends_with("-windows") {
+        names.push(format!("dcr-{target}.exe"));
     }
 
     names

src/cli/flags.rs

@@ -1,18 +1,39 @@
+// 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::config::{PROFILE, flags};
 use crate::utils::log::warn;
 
 pub struct BuildRunFlags {
     pub profile: String,
     pub target: Option<String>,
+    pub workspace: Option<String>,
     pub force: bool,
     pub clean: bool,
+    pub verbose: bool,
 }
 
 pub fn parse_build_run_flags(args: &[String]) -> Result<BuildRunFlags, i32> {
     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();
 
     while let Some(arg) = iter.next() {
@@ -29,6 +50,19 @@ pub fn parse_build_run_flags(args: &[String]) -> Result<BuildRunFlags, i32> {
             clean = true;
             continue;
         }
+        if candidate == "verbose" {
+            verbose = true;
+            continue;
+        }
+        if candidate == "workspace" {
+            if let Some(w) = iter.next() {
+                workspace = Some(w.clone());
+            } else {
+                warn("--workspace requires a value");
+                return Err(1);
+            }
+            continue;
+        }
         if candidate == "target" {
             if let Some(t) = iter.next() {
                 target = Some(t.clone());
@@ -53,7 +87,9 @@ pub fn parse_build_run_flags(args: &[String]) -> Result<BuildRunFlags, i32> {
     Ok(BuildRunFlags {
         profile,
         target,
+        workspace,
         force,
         clean,
+        verbose,
     })
 }

src/cli/gen.rs

@@ -1,3 +1,20 @@
+// 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::builder::BuildContext;
 use crate::core::builder::collect_sources;
 use crate::core::builder::common;
@@ -154,6 +171,7 @@ pub struct ProjectInfo {
     pub profile: String,
     pub language: String,
     pub standard: String,
+    pub cxx_standard: String,
     pub compiler: String,
     pub kind: String,
     pub sources: Vec<String>,
@@ -211,6 +229,7 @@ fn collect_project_info_inner(root: &Path, profile: &str) -> Result<ProjectInfo,
     let version = get_config_str(&config, "package.version");
     let language = get_language_with_profile_or_default(&config, profile);
     let standard = get_string_with_profile(&config, "standard", profile);
+    let cxx_standard = get_string_with_profile(&config, "cxx_standard", profile);
     let compiler_s = get_string_with_profile(&config, "compiler", profile);
     let kind = get_string_with_profile(&config, "kind", profile);
     let build_target = get_string_with_profile(&config, "target", profile);
@@ -322,6 +341,7 @@ fn collect_project_info_inner(root: &Path, profile: &str) -> Result<ProjectInfo,
         compiler: &resolved_compiler,
         language: &language,
         standard: &standard,
+        cxx_standard: &cxx_standard,
         target: Some(build_target.as_str()),
         target_dir: target_dir_binding.as_deref(),
         kind: normalize_kind(&kind),
@@ -337,6 +357,9 @@ fn collect_project_info_inner(root: &Path, profile: &str) -> Result<ProjectInfo,
         libs: &resolved.libs,
         cflags: &resolved_cflags,
         ldflags: &resolved_ldflags,
+        output_filename: None,
+        output_extension: None,
+        verbose: false,
     };
 
     let sources = collect_sources(&ctx).map_err(|e| format!("Failed to collect sources: {e}"))?;
@@ -361,6 +384,7 @@ fn collect_project_info_inner(root: &Path, profile: &str) -> Result<ProjectInfo,
         profile: profile.to_string(),
         language,
         standard,
+        cxx_standard,
         compiler: resolved_compiler,
         kind: normalize_kind(&kind).to_string(),
         sources: abs_sources,
@@ -451,6 +475,10 @@ fn project_info_to_json(info: &ProjectInfo) -> String {
         "    \"standard\": {},\n",
         json_str(&info.standard)
     ));
+    out.push_str(&format!(
+        "    \"cxx_standard\": {},\n",
+        json_str(&info.cxx_standard)
+    ));
     out.push_str(&format!(
         "    \"compiler\": {},\n",
         json_str(&info.compiler)
@@ -555,6 +583,13 @@ fn build_compile_command(info: &ProjectInfo, source: &str, profile: &str) -> Vec
     };
     cmd.push(compiler.to_string());
     cmd.push("-c".to_string());
+
+    // ASM x flag — must be before source file
+    if let Some(flag) = asm_lang_flag(source) {
+        cmd.push("-x".to_string());
+        cmd.push(flag.to_string());
+    }
+
     cmd.push(source.to_string());
 
     // Object path (for -o, approximate — not critical for IntelliSense)
@@ -575,15 +610,18 @@ fn build_compile_command(info: &ProjectInfo, source: &str, profile: &str) -> Vec
         cmd.push("-fPIC".to_string());
     }
 
-    // ASM x flag
-    if let Some(flag) = asm_lang_flag(source) {
-        cmd.push("-x".to_string());
-        cmd.push(flag.to_string());
-    }
-
     // -std=
     if !info.standard.is_empty() && info.language.to_lowercase() != "asm" {
-        cmd.push(format!("-std={}", info.standard));
+        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 && !info.cxx_standard.is_empty() {
+            cmd.push(format!("-std={}", info.cxx_standard));
+        } else if !is_cpp {
+            cmd.push(format!("-std={}", info.standard));
+        }
     }
 
     // Default profile flags (mirrors unix_cc.rs defaults)

src/cli/help.rs

@@ -1,3 +1,20 @@
+// 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::utils::text::{BOLD_CYAN, BOLD_GREEN, printc};
 
 pub fn help() -> i32 {

src/cli/init.rs

@@ -1,3 +1,20 @@
+// 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::config::FILE_MAIN_C;
 use crate::core::config::Config;
 use crate::utils::fs::check_dir;

src/cli/mod.rs

@@ -1,3 +1,20 @@
+// 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 add;
 pub mod build;
 pub mod clean;

src/cli/new.rs

@@ -1,3 +1,20 @@
+// 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::config::FILE_MAIN_C;
 use crate::core::config::Config;
 use crate::utils::fs::check_dir;

src/cli/run.rs

@@ -1,3 +1,20 @@
+// 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::cli::build::build;
 use crate::cli::flags::parse_build_run_flags;
 use crate::core::config::Config;
@@ -7,6 +24,7 @@ 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 std::path::Path;
 use std::process::Command;
 
 fn get_run_cmd(
@@ -65,27 +83,82 @@ pub fn run(args: &[String]) -> i32 {
             return 1;
         }
     };
-    let project_name: &str = config
-        .get("package.name")
-        .and_then(|v| v.as_str())
-        .unwrap_or("");
-    let build_kind = config
-        .get("build.kind")
-        .and_then(|v| v.as_str())
-        .unwrap_or("");
-    let target_dir = config
-        .get("build.target")
-        .and_then(|v| v.as_str())
-        .map(|s| s.trim())
-        .filter(|s| !s.is_empty());
 
-    let mut flags = match parse_build_run_flags(args) {
+    let flags = match parse_build_run_flags(args) {
         Ok(v) => v,
         Err(_) => return 1,
     };
 
+    // Handle workspace-only root: delegate to workspace member
+    if config.is_workspace_only() {
+        let ws = match crate::core::workspace::parse_workspace(
+            &config,
+            &flags.profile,
+            flags.target.as_deref(),
+            &root,
+        ) {
+            Ok(Some(ws)) => ws,
+            Ok(None) => {
+                error("Workspace root has no members defined");
+                return 1;
+            }
+            Err(e) => {
+                error(&e);
+                return 1;
+            }
+        };
+        let member = match &flags.workspace {
+            Some(name) => ws.members.iter().find(|m| m.name == *name),
+            None => ws.main_member(),
+        };
+        let member = match member {
+            Some(m) => m,
+            None => {
+                if let Some(name) = &flags.workspace {
+                    error(&format!("Workspace member '{name}' not found"));
+                } else {
+                    error("No workspace member to run (set `main = true` on one member)");
+                }
+                return 1;
+            }
+        };
+        // Build and run from the member's directory
+        return match with_dir(&member.path, || {
+            run_project(&member.path, &flags, Some(root.as_path()))
+        }) {
+            Ok(code) => code,
+            Err(e) => {
+                error(&e);
+                1
+            }
+        };
+    }
+
+    match run_project(&root, &flags, None) {
+        Ok(code) => code,
+        Err(e) => {
+            error(&e);
+            1
+        }
+    }
+}
+
+fn run_project(
+    root: &Path,
+    flags: &crate::cli::flags::BuildRunFlags,
+    workspace_root: Option<&Path>,
+) -> Result<i32, String> {
+    let config =
+        Config::open(root.join("dcr.toml").to_str().unwrap()).map_err(|err| err.to_string())?;
+
+    let project_name: &str = config
+        .get("package.name")
+        .and_then(|v| v.as_str())
+        .unwrap_or("");
+
     // If no target specified, use default host target for target-specific config
-    if flags.target.is_none() {
+    let mut target = flags.target.clone();
+    if target.is_none() {
         let default_target = if cfg!(target_os = "linux") {
             "x86_64-unknown-linux-gnu"
         } else if cfg!(target_os = "macos") {
@@ -95,26 +168,39 @@ pub fn run(args: &[String]) -> i32 {
         } else {
             "unknown"
         };
-        flags.target = Some(default_target.to_string());
+        target = Some(default_target.to_string());
     }
 
-    let normalized_target_dir = flags
-        .target
-        .as_ref()
-        .and_then(|t| crate::cli::build::normalize_target(t, &flags.profile));
+    let build_kind = config
+        .get(&format!("build.{}.kind", flags.profile))
+        .and_then(|v| v.as_str())
+        .or_else(|| config.get("build.kind").and_then(|v| v.as_str()))
+        .unwrap_or("");
+
+    let normalized_target_dir = match workspace_root {
+        Some(wr) => target
+            .as_ref()
+            .and_then(|t| crate::cli::build::normalize_target(t, &flags.profile))
+            .map(|rel| wr.join(&rel).to_string_lossy().to_string()),
+        None => target
+            .as_ref()
+            .and_then(|t| crate::cli::build::normalize_target(t, &flags.profile)),
+    };
 
     let version = config
         .get("package.version")
         .and_then(|v| v.as_str())
         .unwrap_or("");
-    let run_cmd = get_run_cmd(&config, &flags.profile, flags.target.as_deref(), version);
+    let run_cmd = get_run_cmd(&config, &flags.profile, target.as_deref(), version);
 
     let kind = build_kind.trim();
-    if run_cmd.is_none() && (kind == "staticlib" || kind == "sharedlib") {
-        error("Cannot run library build");
-        return 1;
+    if run_cmd.is_none()
+        && (kind == "staticlib" || kind == "sharedlib" || kind == "efi" || kind == "elf")
+    {
+        return Err("Cannot run library build".to_string());
     }
-    let build_status = build(args);
+
+    let build_status = build(&args_for_build(flags));
     let bin_path = crate::platform::bin_path(
         &flags.profile,
         project_name,
@@ -124,24 +210,48 @@ pub fn run(args: &[String]) -> i32 {
         if let Some(cmd) = run_cmd {
             println!("\n    {} {}", colored("Running", BOLD_GREEN), cmd);
             println!("--------------------------------");
-            return run_shell(&cmd);
+            return Ok(run_shell(&cmd));
         }
         println!("\n    {} {}", colored("Running", BOLD_GREEN), bin_path);
         println!("--------------------------------");
-        return run_binary(project_name, &flags.profile, target_dir);
+        return Ok(run_binary(
+            project_name,
+            &flags.profile,
+            normalized_target_dir.as_deref(),
+        ));
     }
 
     let fallback_code = if let Some(cmd) = run_cmd {
         run_shell(&cmd)
     } else {
-        run_binary(project_name, &flags.profile, target_dir)
+        run_binary(
+            project_name,
+            &flags.profile,
+            normalized_target_dir.as_deref(),
+        )
     };
     if fallback_code != 1 {
-        return fallback_code;
+        return Ok(fallback_code);
     }
 
-    error("Fix errors in the code to run the project");
-    1
+    Err("Fix errors in the code to run the project".to_string())
+}
+
+fn args_for_build(flags: &crate::cli::flags::BuildRunFlags) -> 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());
+    }
+    if let Some(ref name) = flags.workspace {
+        args.push("--workspace".to_string());
+        args.push(name.clone());
+    }
+    if flags.verbose {
+        args.push("--verbose".to_string());
+    }
+    args
 }
 
 fn run_shell(cmd: &str) -> i32 {

src/cli/setup.rs

@@ -1,3 +1,20 @@
+// 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 fn setup(_args: &[String]) -> i32 {
     println!("Setting up DCR registries...");
     match crate::core::registry::RegistryManager::load() {

src/cli/test.rs

@@ -1,3 +1,20 @@
+// 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::cli::build;
 use crate::config::{FILE_DCR_TEST_H, FILE_TEST_C, flags};
 use crate::core::config::Config;
@@ -16,10 +33,11 @@ const BOLD_BLUE: &str = "\x1b[1m\x1b[94m";
 
 pub fn test(args: &[String]) -> i32 {
     let mut init_header = false;
+    let mut profile = "debug";
     for arg in args {
         if arg == "--help" {
             println!("USAGE:");
-            println!("    dcr test [--init]");
+            println!("    dcr test [--init] [--debug | --release]");
             println!();
             println!("ALIASES:");
             println!("    dcr tests");
@@ -29,12 +47,18 @@ pub fn test(args: &[String]) -> i32 {
             println!();
             println!("OPTIONS:");
             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");
             return 0;
         }
         if arg == "--init" {
             init_header = true;
             continue;
         }
+        if arg == "--debug" || arg == "--release" {
+            profile = arg.trim_start_matches("--");
+            continue;
+        }
         error("Unknown argument");
         return 1;
     }
@@ -68,7 +92,7 @@ pub fn test(args: &[String]) -> i32 {
         }
     }
 
-    match with_dir(&root, run_testsuite) {
+    match with_dir(&root, || run_testsuite(profile)) {
         Ok(code) => code,
         Err(msg) => {
             error(&msg);
@@ -77,13 +101,12 @@ pub fn test(args: &[String]) -> i32 {
     }
 }
 
-fn run_testsuite() -> Result<i32, String> {
-    if build::build(&[String::from("--release")]) != 0 {
+fn run_testsuite(profile: &str) -> Result<i32, String> {
+    if build::build(&[format!("--{profile}")]) != 0 {
         return Ok(1);
     }
 
     let config = Config::open("./dcr.toml").map_err(|_| "Failed to read dcr.toml".to_string())?;
-    let profile = "release";
     let name = get_config_str(&config, "package.name");
     let language = get_language_with_profile(&config, profile)?;
     let compiler_cfg = get_string_with_profile(&config, "compiler", profile);

src/cli/tree.rs

@@ -1,3 +1,20 @@
+// 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::config::Config;
 use crate::utils::log::error;
 use crate::utils::text::{BOLD_CYAN, printc};

src/config.rs

@@ -1,3 +1,20 @@
+// 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 const PROFILE: &str = "debug";
 pub const FILE_MAIN_C: &str = r#"#include <stdio.h>
 

src/core/builder/common.rs

@@ -1,3 +1,20 @@
+// 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 std::fs;
 use std::path::{Path, PathBuf};
 use std::process::Command;
@@ -5,6 +22,10 @@ use std::sync::{Mutex, OnceLock};
 
 static OUTPUT_MUTEX: OnceLock<Mutex<()>> = OnceLock::new();
 
+pub fn get_output_lock() -> &'static Mutex<()> {
+    OUTPUT_MUTEX.get_or_init(|| Mutex::new(()))
+}
+
 pub fn collect_sources(
     roots: &[PathBuf],
     extensions: &[&str],
@@ -230,12 +251,33 @@ pub fn normalize_source_path(path: &Path) -> String {
 
 pub fn object_path(obj_dir: &Path, source: &str, obj_ext: &str) -> String {
     let src_path = Path::new(source);
-    let rel = src_path
-        .strip_prefix("./src")
-        .or_else(|_| src_path.strip_prefix("src"))
-        .unwrap_or(src_path);
+    let stripped = src_path.strip_prefix("./").unwrap_or(src_path);
+    let rel = stripped
+        .components()
+        .skip(1)
+        .collect::<std::path::PathBuf>();
+    let rel = if rel.components().next().is_some() {
+        rel
+    } else {
+        stripped.to_path_buf()
+    };
     let mut out = obj_dir.join(rel);
-    out.set_extension(obj_ext.trim_start_matches('.'));
+    let ext = out
+        .extension()
+        .and_then(|e| e.to_str())
+        .unwrap_or("")
+        .to_string();
+    let obj_ext = obj_ext.trim_start_matches('.');
+    if !ext.is_empty() {
+        let stem = out
+            .file_stem()
+            .and_then(|s| s.to_str())
+            .unwrap_or("")
+            .to_string();
+        out.set_file_name(format!("{stem}.{ext}.{obj_ext}"));
+    } else {
+        out.set_extension(obj_ext);
+    }
     out.to_string_lossy().to_string()
 }
 
@@ -352,28 +394,28 @@ mod tests {
     fn object_path_basic() {
         let obj_dir = Path::new("target/debug/obj");
         let result = object_path(obj_dir, "./src/main.c", "o");
-        assert_eq!(result, "target/debug/obj/main.o");
+        assert_eq!(result, "target/debug/obj/main.c.o");
     }
 
     #[test]
     fn object_path_nested() {
         let obj_dir = Path::new("target/debug/obj");
         let result = object_path(obj_dir, "./src/core/utils.c", "o");
-        assert_eq!(result, "target/debug/obj/core/utils.o");
+        assert_eq!(result, "target/debug/obj/core/utils.c.o");
     }
 
     #[test]
     fn object_path_no_prefix() {
         let obj_dir = Path::new("target/debug/obj");
         let result = object_path(obj_dir, "src/main.c", "o");
-        assert_eq!(result, "target/debug/obj/main.o");
+        assert_eq!(result, "target/debug/obj/main.c.o");
     }
 
     #[test]
     fn object_path_msvc_ext() {
         let obj_dir = Path::new("target/debug/obj");
         let result = object_path(obj_dir, "./src/main.c", "obj");
-        assert_eq!(result, "target/debug/obj/main.obj");
+        assert_eq!(result, "target/debug/obj/main.c.obj");
     }
 
     #[test]

src/core/builder/gas.rs

@@ -1,3 +1,20 @@
+// 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::builder::BuildContext;
 use crate::core::builder::common;
 use crate::platform;
@@ -8,7 +25,7 @@ use std::time::Instant;
 
 pub fn build(ctx: &BuildContext) -> Result<f64, String> {
     let lang = ctx.language.to_lowercase();
-    if lang.split('+').any(|p| p.trim() != "asm") {
+    if lang.split(',').any(|p| p.trim() != "asm") {
         return Err("GAS backend requires build.language = \"asm\"".to_string());
     }
     let assembler = if ctx.compiler.is_empty() {
@@ -18,7 +35,10 @@ pub fn build(ctx: &BuildContext) -> Result<f64, String> {
     };
     let start_time = Instant::now();
     let sources = collect_sources(ctx)?;
-    let obj_dir = Path::new("./target").join(ctx.profile).join("obj");
+    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 = build_objects(assembler, &sources, &obj_dir, ctx, "o")?;
 
     if ctx.kind == "staticlib" {
@@ -37,7 +57,7 @@ pub fn build(ctx: &BuildContext) -> Result<f64, String> {
         for obj in &objects {
             cmd.arg(obj);
         }
-        if std::env::var("DCR_DEBUG").is_ok() {
+        if ctx.verbose || std::env::var("DCR_DEBUG").is_ok() {
             eprintln!("[dcr] {:?}", cmd);
         }
         match cmd.status() {
@@ -70,14 +90,24 @@ pub fn build(ctx: &BuildContext) -> Result<f64, String> {
     for flag in ctx.ldflags {
         cmd.arg(flag);
     }
-    let out_path = if ctx.kind == "sharedlib" {
-        platform::shared_lib_path(ctx.profile, ctx.project_name, ctx.target_dir)
+    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 {
-        platform::bin_path(ctx.profile, ctx.project_name, ctx.target_dir)
+        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 == "elf" {
+        platform::elf_path(ctx.profile, &final_name, ctx.target_dir)
+    } else {
+        platform::bin_path(ctx.profile, &final_name, ctx.target_dir)
     };
     cmd.arg("-o").arg(out_path);
 
-    if std::env::var("DCR_DEBUG").is_ok() {
+    if ctx.verbose || std::env::var("DCR_DEBUG").is_ok() {
         eprintln!("[dcr] {:?}", cmd);
     }
     match cmd.status() {

src/core/builder/mod.rs

@@ -1,3 +1,20 @@
+// 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 common;
 pub mod gas;
 pub mod msvc;
@@ -10,7 +27,7 @@ pub struct BuildContext<'a> {
     pub compiler: &'a str,
     pub language: &'a str,
     pub standard: &'a str,
-    #[allow(dead_code)]
+    pub cxx_standard: &'a str,
     pub target: Option<&'a str>,
     pub target_dir: Option<&'a str>,
     pub kind: &'a str,
@@ -26,10 +43,19 @@ pub struct BuildContext<'a> {
     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 fn build(ctx: &BuildContext) -> Result<f64, String> {
     let compiler = ctx.compiler.to_lowercase();
+    if !check_compiler_exists(ctx.compiler) {
+        return Err(format!(
+            "Compiler not found: {}. Make sure it is installed and available in PATH.",
+            ctx.compiler
+        ));
+    }
     if compiler.contains("clang-cl") {
         return msvc::build(ctx);
     }
@@ -45,6 +71,14 @@ pub fn build(ctx: &BuildContext) -> Result<f64, String> {
     unix_cc::build(ctx)
 }
 
+fn check_compiler_exists(compiler: &str) -> bool {
+    let name = if compiler.is_empty() { "cc" } else { compiler };
+    std::process::Command::new(name)
+        .arg("--version")
+        .output()
+        .is_ok()
+}
+
 pub fn collect_sources(ctx: &BuildContext) -> Result<Vec<String>, String> {
     let compiler = ctx.compiler.to_lowercase();
     if compiler.contains("clang-cl") || compiler == "cl" || compiler.contains("msvc") {

src/core/builder/msvc.rs

@@ -1,3 +1,20 @@
+// 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::builder::BuildContext;
 use crate::core::builder::common;
 use crate::platform;
@@ -18,7 +35,10 @@ pub fn build(ctx: &BuildContext) -> Result<f64, String> {
     }
     let start_time = Instant::now();
     let sources = collect_sources(ctx)?;
-    let obj_dir = Path::new("./target").join(ctx.profile).join("obj");
+    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 = build_objects(compiler, &sources, &obj_dir, ctx, "obj")?;
 
     if ctx.kind == "staticlib" {
@@ -28,7 +48,7 @@ pub fn build(ctx: &BuildContext) -> Result<f64, String> {
         for obj in &objects {
             cmd.arg(obj);
         }
-        if std::env::var("DCR_DEBUG").is_ok() {
+        if ctx.verbose || std::env::var("DCR_DEBUG").is_ok() {
             eprintln!("[dcr] {:?}", cmd);
         }
         match cmd.status() {
@@ -92,12 +112,14 @@ pub fn build(ctx: &BuildContext) -> Result<f64, String> {
     }
     let out_path = if ctx.kind == "sharedlib" {
         platform::shared_lib_path(ctx.profile, ctx.project_name, ctx.target_dir)
+    } else if ctx.kind == "elf" {
+        platform::elf_path(ctx.profile, ctx.project_name, ctx.target_dir)
     } else {
         platform::bin_path(ctx.profile, ctx.project_name, ctx.target_dir)
     };
     cmd.arg(format!("/Fe:{out_path}"));
 
-    if std::env::var("DCR_DEBUG").is_ok() {
+    if ctx.verbose || std::env::var("DCR_DEBUG").is_ok() {
         eprintln!("[dcr] {:?}", cmd);
     }
     match cmd.status() {
@@ -122,8 +144,8 @@ pub(crate) fn collect_sources(ctx: &BuildContext) -> Result<Vec<String>, String>
 
 fn source_extensions(language: &str) -> Vec<&str> {
     let mut out = Vec::new();
-    for part in language.split('+') {
-        let lang = part.trim().to_lowercase();
+    for part in language.split(',').map(|s| s.trim()) {
+        let lang = part.to_lowercase();
         match lang.as_str() {
             "c" => out.extend(["c"]),
             "c++" | "cpp" | "cxx" => out.extend(["cpp", "cxx", "cc"]),
@@ -185,8 +207,6 @@ fn default_flags(profile: &str) -> &'static [&'static str] {
     }
 }
 
-static OUTPUT_MUTEX: std::sync::Mutex<()> = std::sync::Mutex::new(());
-
 fn build_objects(
     compiler: &str,
     sources: &[String],
@@ -223,18 +243,26 @@ fn build_object(
     let mut cmd = Command::new(compiler);
     cmd.arg("/nologo");
 
-    match ctx.language.to_lowercase().as_str() {
-        "c" => {
-            cmd.arg("/TC");
-        }
-        "c++" | "cpp" | "cxx" => {
-            cmd.arg("/TP");
-        }
-        _ => return Err("Unsupported language".to_string()),
+    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 {
+        cmd.arg("/TP");
+    } else {
+        cmd.arg("/TC");
     }
 
-    if !ctx.standard.is_empty() && ctx.language.to_lowercase() != "asm" {
-        let std_flag = msvc_standard_flag(ctx.language, ctx.standard)?;
+    let std_val = if is_cpp && !ctx.cxx_standard.is_empty() {
+        ctx.cxx_standard
+    } else if !is_cpp && !ctx.standard.is_empty() {
+        ctx.standard
+    } else {
+        ""
+    };
+    if !std_val.is_empty() {
+        let std_flag = msvc_standard_flag(if is_cpp { "c++" } else { "c" }, std_val)?;
         cmd.arg(std_flag);
     }
 
@@ -282,7 +310,7 @@ fn build_object(
         }
     }
 
-    let _lock = OUTPUT_MUTEX.lock().unwrap();
+    let _lock = common::get_output_lock().lock().unwrap();
 
     if !output.status.success() {
         eprint!("{}", clean_stdout);

src/core/builder/nasm.rs

@@ -1,3 +1,20 @@
+// 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::builder::BuildContext;
 use crate::core::builder::common;
 use crate::platform;
@@ -8,7 +25,7 @@ use std::time::Instant;
 
 pub fn build(ctx: &BuildContext) -> Result<f64, String> {
     let lang = ctx.language.to_lowercase();
-    if lang.split('+').any(|p| p.trim() != "asm") {
+    if lang.split(',').any(|p| p.trim() != "asm") {
         return Err("NASM backend requires build.language = \"asm\"".to_string());
     }
     let assembler = if ctx.compiler.is_empty() {
@@ -18,7 +35,10 @@ pub fn build(ctx: &BuildContext) -> Result<f64, String> {
     };
     let start_time = Instant::now();
     let sources = collect_sources(ctx)?;
-    let obj_dir = Path::new("./target").join(ctx.profile).join("obj");
+    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 = build_objects(assembler, &sources, &obj_dir, ctx, "o")?;
 
     if ctx.kind == "staticlib" {
@@ -37,7 +57,7 @@ pub fn build(ctx: &BuildContext) -> Result<f64, String> {
         for obj in &objects {
             cmd.arg(obj);
         }
-        if std::env::var("DCR_DEBUG").is_ok() {
+        if ctx.verbose || std::env::var("DCR_DEBUG").is_ok() {
             eprintln!("[dcr] {:?}", cmd);
         }
         match cmd.status() {
@@ -70,14 +90,24 @@ pub fn build(ctx: &BuildContext) -> Result<f64, String> {
     for flag in ctx.ldflags {
         cmd.arg(flag);
     }
-    let out_path = if ctx.kind == "sharedlib" {
-        platform::shared_lib_path(ctx.profile, ctx.project_name, ctx.target_dir)
+    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 {
-        platform::bin_path(ctx.profile, ctx.project_name, ctx.target_dir)
+        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 == "elf" {
+        platform::elf_path(ctx.profile, &final_name, ctx.target_dir)
+    } else {
+        platform::bin_path(ctx.profile, &final_name, ctx.target_dir)
     };
     cmd.arg("-o").arg(out_path);
 
-    if std::env::var("DCR_DEBUG").is_ok() {
+    if ctx.verbose || std::env::var("DCR_DEBUG").is_ok() {
         eprintln!("[dcr] {:?}", cmd);
     }
     match cmd.status() {
@@ -147,7 +177,7 @@ fn build_object(
         cmd.arg(flag);
     }
 
-    if std::env::var("DCR_DEBUG").is_ok() {
+    if ctx.verbose || std::env::var("DCR_DEBUG").is_ok() {
         eprintln!("[dcr] {:?}", cmd);
     }
 

src/core/builder/unix_cc.rs

@@ -1,3 +1,20 @@
+// 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::builder::BuildContext;
 use crate::core::builder::common;
 use crate::platform;
@@ -20,7 +37,10 @@ pub fn build(ctx: &BuildContext) -> Result<f64, String> {
         ctx.exclude_dirs,
         ctx.include_paths,
     )?;
-    let obj_dir = Path::new("./target").join(ctx.profile).join("obj");
+    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 = build_objects(compiler, &sources, &obj_dir, ctx, "o")?;
 
     if ctx.kind == "staticlib" {
@@ -30,7 +50,7 @@ pub fn build(ctx: &BuildContext) -> Result<f64, String> {
         for obj in &objects {
             cmd.arg(obj);
         }
-        if std::env::var("DCR_DEBUG").is_ok() {
+        if ctx.verbose || std::env::var("DCR_DEBUG").is_ok() {
             eprintln!("[dcr] {:?}", cmd);
         }
         match cmd.status() {
@@ -51,6 +71,12 @@ pub fn build(ctx: &BuildContext) -> Result<f64, String> {
             cmd.arg("-shared");
         }
     }
+    if ctx.kind == "efi" {
+        cmd.arg("-shared");
+        cmd.arg("-nostdlib");
+        cmd.arg("-Wl,-dll");
+        cmd.arg("-Wl,--subsystem,10");
+    }
     for obj in &objects {
         cmd.arg(obj);
     }
@@ -63,14 +89,26 @@ pub fn build(ctx: &BuildContext) -> Result<f64, String> {
     for flag in ctx.ldflags {
         cmd.arg(flag);
     }
-    let out_path = if ctx.kind == "sharedlib" {
-        platform::shared_lib_path(ctx.profile, ctx.project_name, ctx.target_dir)
+    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 {
-        platform::bin_path(ctx.profile, ctx.project_name, ctx.target_dir)
+        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)
     };
     cmd.arg("-o").arg(out_path);
 
-    if std::env::var("DCR_DEBUG").is_ok() {
+    if ctx.verbose || std::env::var("DCR_DEBUG").is_ok() {
         eprintln!("[dcr] {:?}", cmd);
     }
     match cmd.status() {
@@ -95,8 +133,8 @@ pub(crate) fn collect_sources(ctx: &BuildContext) -> Result<Vec<String>, String>
 
 fn source_extensions(language: &str) -> Vec<&str> {
     let mut out = Vec::new();
-    for part in language.split('+') {
-        let lang = part.trim().to_lowercase();
+    for part in language.split(',').map(|s| s.trim()) {
+        let lang = part.to_lowercase();
         match lang.as_str() {
             "c" => out.extend(["c"]),
             "c++" | "cpp" | "cxx" => out.extend(["cpp", "cxx", "cc"]),
@@ -125,6 +163,19 @@ fn default_flags(profile: &str) -> &'static [&'static str] {
     }
 }
 
+fn is_bare_metal_target(target: Option<&str>) -> bool {
+    if let Some(t) = target {
+        let lower = t.to_lowercase();
+        lower.contains("none")
+            || lower.contains("-elf")
+            || lower.contains("eabi")
+            || lower.contains("baremetal")
+            || lower.contains("bare-metal")
+    } else {
+        false
+    }
+}
+
 fn build_objects(
     compiler: &str,
     sources: &[String],
@@ -159,16 +210,18 @@ fn build_object(
     }
 
     let mut cmd = Command::new(compiler);
-    cmd.arg("-c").arg(source).arg("-o").arg(obj_path);
-
-    if ctx.kind == "sharedlib" {
-        cmd.arg("-fPIC");
-    }
+    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 let Some(platform) = ctx.platform
         && !platform.trim().is_empty()
     {
@@ -176,10 +229,20 @@ fn build_object(
     }
 
     if !ctx.standard.is_empty() && ctx.language.to_lowercase() != "asm" {
-        cmd.arg(format!("-std={}", ctx.standard));
+        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));
+        }
     }
 
-    if ctx.cflags.is_empty() {
+    let use_dcr_defaults = ctx.cflags.is_empty() && !is_bare_metal_target(ctx.target);
+    if use_dcr_defaults {
         for flag in default_flags(ctx.profile) {
             cmd.arg(flag);
         }
@@ -196,7 +259,7 @@ fn build_object(
     let d_path = Path::new(obj_path).with_extension("d");
     cmd.arg("-MMD").arg("-MF").arg(&d_path);
 
-    if std::env::var("DCR_DEBUG").is_ok() {
+    if ctx.verbose || std::env::var("DCR_DEBUG").is_ok() {
         eprintln!("[dcr] {:?}", cmd);
     }
 

src/core/config.rs

@@ -1,3 +1,20 @@
+// 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 serde::Deserialize;
 use std::collections::BTreeMap;
 use std::fs;
@@ -10,6 +27,7 @@ const DEFAULT_LANGUAGE: &str = "c";
 const DEFAULT_STANDARD: &str = "c11";
 const DEFAULT_COMPILER: &str = "clang";
 const DEFAULT_KIND: &str = "bin";
+const VALID_KINDS: &[&str] = &["bin", "staticlib", "sharedlib", "efi", "elf"];
 
 #[derive(Debug)]
 pub enum ConfigError {
@@ -59,8 +77,10 @@ pub struct Config {
 #[allow(dead_code)]
 #[derive(Debug, Clone, Deserialize)]
 pub struct DcrConfig {
-    pub package: PackageConfig,
-    pub build: BuildConfig,
+    #[serde(default)]
+    pub package: Option<PackageConfig>,
+    #[serde(default)]
+    pub build: Option<BuildConfig>,
     #[serde(default)]
     pub dependencies: BTreeMap<String, DependencyConfig>,
     #[serde(default)]
@@ -82,6 +102,8 @@ pub struct PackageConfig {
 pub struct BuildConfig {
     pub language: LanguageConfig,
     pub standard: String,
+    #[serde(default)]
+    pub cxx_standard: Option<String>,
     pub compiler: String,
     #[serde(default)]
     pub kind: Option<String>,
@@ -103,6 +125,8 @@ pub struct BuildConfig {
     pub clean: Vec<String>,
     #[serde(default)]
     pub src_disable: Option<bool>,
+    #[serde(default)]
+    pub workspace_only: bool,
 }
 
 #[derive(Debug, Clone, Deserialize)]
@@ -181,13 +205,100 @@ impl Config {
     }
 
     #[allow(dead_code)]
-    pub fn package(&self) -> &PackageConfig {
-        &self.typed.package
+    pub fn package(&self) -> Option<&PackageConfig> {
+        self.typed.package.as_ref()
     }
 
     #[allow(dead_code)]
-    pub fn build_config(&self) -> &BuildConfig {
-        &self.typed.build
+    pub fn build_config(&self) -> Option<&BuildConfig> {
+        self.typed.build.as_ref()
+    }
+
+    pub fn is_workspace_only(&self) -> bool {
+        self.typed
+            .build
+            .as_ref()
+            .map(|b| b.workspace_only)
+            .unwrap_or(false)
+            && !self.typed.workspace.is_empty()
+    }
+
+    /// Merge build fields from parent config into self where self has empty/default values.
+    /// Used for workspace member inheritance (build.inherit = true).
+    pub fn merge_parent(&mut self, parent: &Config) {
+        let fields: &[&str] = &[
+            "language",
+            "standard",
+            "cxx_standard",
+            "compiler",
+            "kind",
+            "target",
+            "platform",
+            "cflags",
+            "ldflags",
+            "exclude",
+            "include",
+            "roots",
+            "clean",
+            "src_disable",
+        ];
+        let parent_build = match parent.data.get("build").and_then(|v| v.as_table()) {
+            Some(t) => t.clone(),
+            None => return,
+        };
+
+        let self_build = self
+            .data
+            .get("build")
+            .and_then(|v| v.as_table())
+            .cloned()
+            .unwrap_or_default();
+
+        let mut changes: Vec<(String, toml::Value)> = Vec::new();
+
+        for field in fields {
+            let val = match parent_build.get(*field) {
+                Some(v) => v,
+                None => continue,
+            };
+
+            let self_val = self_build.get(*field);
+            let should_inherit = match val {
+                toml::Value::Array(_) => self_val.is_none(),
+                toml::Value::String(_) => self_val
+                    .and_then(|v| v.as_str())
+                    .map(|s| s.trim().is_empty())
+                    .unwrap_or(true),
+                _ => self_val.is_none(),
+            };
+            if should_inherit {
+                changes.push((field.to_string(), val.clone()));
+            }
+        }
+
+        if changes.is_empty() {
+            return;
+        }
+
+        if !self.data.is_table() {
+            let mut m = Map::new();
+            m.insert("build".to_string(), toml::Value::Table(Map::new()));
+            self.data = toml::Value::Table(m);
+        }
+
+        let tbl = self.data.as_table_mut().unwrap();
+        let build_tbl = tbl
+            .entry("build".to_string())
+            .or_insert_with(|| toml::Value::Table(Map::new()));
+        if let Some(build_tbl) = build_tbl.as_table_mut() {
+            for (key, val) in changes {
+                build_tbl.entry(key).or_insert(val);
+            }
+        }
+
+        if let Ok(typed) = parse_typed_config(&self.data) {
+            self.typed = typed;
+        }
     }
 
     pub fn get(&self, key: &str) -> Option<&Value> {
@@ -209,15 +320,29 @@ impl Config {
     }
 
     pub fn validate(&self) -> Result<(), ConfigError> {
-        if self.typed.package.name.trim().is_empty() {
+        if self.is_workspace_only() {
+            return self.validate_workspace();
+        }
+
+        let pkg =
+            self.typed.package.as_ref().ok_or_else(|| {
+                ConfigError::Invalid("missing [package] section (required)".into())
+            })?;
+        let build = self
+            .typed
+            .build
+            .as_ref()
+            .ok_or_else(|| ConfigError::Invalid("missing [build] section (required)".into()))?;
+
+        if pkg.name.trim().is_empty() {
             return Err(ConfigError::Invalid("package.name is empty".into()));
         }
-        if self.typed.package.version.trim().is_empty() {
+        if pkg.version.trim().is_empty() {
             return Err(ConfigError::Invalid("package.version is empty".into()));
         }
-        validate_package_name(&self.typed.package.name)?;
+        validate_package_name(&pkg.name)?;
 
-        if let Some(pkg_type) = &self.typed.package.pkg_type {
+        if let Some(pkg_type) = &pkg.pkg_type {
             let pkg_type = pkg_type.trim();
             if !pkg_type.is_empty() && pkg_type != "lib" && pkg_type != "app" && pkg_type != "none"
             {
@@ -227,32 +352,32 @@ impl Config {
             }
         }
 
-        validate_language_config(&self.typed.build.language, "build.language")?;
-        if self.typed.build.standard.trim().is_empty() {
+        validate_language_config(&build.language, "build.language")?;
+        if build.standard.trim().is_empty() {
             return Err(ConfigError::Invalid("build.standard is empty".into()));
         }
-        if self.typed.build.compiler.trim().is_empty() {
+        if build.compiler.trim().is_empty() {
             return Err(ConfigError::Invalid("build.compiler is empty".into()));
         }
-        if let Some(platform) = &self.typed.build.platform
+        if let Some(platform) = &build.platform
             && platform.trim().is_empty()
         {
             return Err(ConfigError::Invalid("build.platform is empty".into()));
         }
         validate_toolchain(self.typed.toolchain.as_ref())?;
-        if let Some(kind) = &self.typed.build.kind {
+        if let Some(kind) = &build.kind {
             let kind = kind.trim();
-            if !kind.is_empty() && kind != "bin" && kind != "staticlib" && kind != "sharedlib" {
+            if !kind.is_empty() && !VALID_KINDS.contains(&kind) {
                 return Err(ConfigError::Invalid("build.kind is invalid".into()));
             }
         }
-        validate_string_list(&self.typed.build.exclude, "build.exclude")?;
-        validate_string_list(&self.typed.build.include, "build.include")?;
-        validate_string_list(&self.typed.build.roots, "build.roots")?;
-        validate_string_list(&self.typed.build.clean, "build.clean")?;
-        validate_string_list(&self.typed.build.cflags, "build.cflags")?;
-        validate_string_list(&self.typed.build.ldflags, "build.ldflags")?;
-        if let Some(target) = &self.typed.build.target {
+        validate_string_list(&build.exclude, "build.exclude")?;
+        validate_string_list(&build.include, "build.include")?;
+        validate_string_list(&build.roots, "build.roots")?;
+        validate_string_list(&build.clean, "build.clean")?;
+        validate_string_list(&build.cflags, "build.cflags")?;
+        validate_string_list(&build.ldflags, "build.ldflags")?;
+        if let Some(target) = &build.target {
             validate_non_empty_string(target, "build.target")?;
         }
         for profile in ["release", "debug"] {
@@ -410,7 +535,7 @@ impl Config {
         }
         if let Some(kind) = table.get("kind").and_then(|v| v.as_str()) {
             let kind = kind.trim();
-            if !kind.is_empty() && kind != "bin" && kind != "staticlib" && kind != "sharedlib" {
+            if !kind.is_empty() && !VALID_KINDS.contains(&kind) {
                 return Err(ConfigError::Invalid(format!(
                     "build.{profile}.kind is invalid"
                 )));
@@ -534,7 +659,10 @@ fn default_toml() -> Result<Value, ConfigError> {
     package.insert("type".to_string(), Value::String("none".to_string()));
     package.insert("description".to_string(), Value::String("".to_string()));
     package.insert("author".to_string(), Value::String("".to_string()));
-    package.insert("license".to_string(), Value::String("MIT".to_string()));
+    package.insert(
+        "license".to_string(),
+        Value::String("GPL-3.0-or-later".to_string()),
+    );
 
     let mut build = Map::new();
     build.insert(
@@ -801,10 +929,10 @@ mod tests {
             "[package]\nname = \"typed\"\nversion = \"1.2.3\"\ntype = \"lib\"\n\n[build]\nlanguage = [\"c\", \"c++\"]\nstandard = \"c11\"\ncompiler = \"clang\"\nkind = \"staticlib\"\ncflags = [\"-Wall\"]\n\n[dependencies]\nfoo = \"1.0.0\"\n",
         );
         let config = Config::open(&path.to_string_lossy()).unwrap();
-        assert_eq!(config.package().name, "typed");
-        assert_eq!(config.typed().package.version, "1.2.3");
-        assert_eq!(config.build_config().compiler, "clang");
-        assert_eq!(config.build_config().cflags, ["-Wall"]);
+        assert_eq!(config.package().unwrap().name, "typed");
+        assert_eq!(config.typed().package.as_ref().unwrap().version, "1.2.3");
+        assert_eq!(config.build_config().unwrap().compiler, "clang");
+        assert_eq!(config.build_config().unwrap().cflags, ["-Wall"]);
         assert!(config.typed().dependencies.contains_key("foo"));
     }
 
@@ -919,14 +1047,16 @@ mod tests {
 
     #[test]
     fn validate_valid_kinds() {
-        for kind in ["bin", "staticlib", "sharedlib"] {
-            let dir = temp_dir(&format!("kind_{kind}"));
-            let content = format!(
+        for &kind in VALID_KINDS {
+            let dir = temp_dir("valid_kind");
+            let toml = format!(
                 "[package]\nname = \"test\"\nversion = \"0.1.0\"\n\n[build]\nlanguage = \"c\"\nstandard = \"c11\"\ncompiler = \"clang\"\nkind = \"{kind}\"\n\n[dependencies]\n"
             );
-            let path = write_toml_file(&dir, &content);
-            let result = Config::open(&path.to_string_lossy());
-            assert!(result.is_ok(), "kind '{kind}' should be valid");
+            let path = write_toml_file(&dir, &toml);
+            assert!(
+                Config::open(&path.to_string_lossy()).is_ok(),
+                "kind '{kind}' should be valid"
+            );
         }
     }
 

src/core/deps/common.rs

@@ -1,3 +1,20 @@
+// 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/>.
+
 #[allow(dead_code)]
 use std::fs;
 use std::path::{Path, PathBuf};

src/core/deps/git.rs

@@ -1,3 +1,20 @@
+// 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 std::path::Path;
 
 #[allow(dead_code)]

src/core/deps/lock.rs

@@ -1,3 +1,20 @@
+// 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 sha2::{Digest, Sha256};
 use std::fs;
 use std::path::Path;

src/core/deps/mod.rs

@@ -1,3 +1,20 @@
+// 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 common;
 pub mod git;
 pub mod lock;
@@ -5,8 +22,20 @@ pub mod register;
 
 use crate::core::config::Config;
 use crate::core::deps::common::ResolvedDeps;
+use crate::core::deps::lock::{DepLock, write_lock};
 use std::path::Path;
 
+fn dep_version(path: &Path) -> String {
+    Config::open(&path.join("dcr.toml").to_string_lossy())
+        .ok()
+        .and_then(|c| {
+            c.get("package.version")
+                .and_then(|v| v.as_str())
+                .map(|s| s.to_string())
+        })
+        .unwrap_or_default()
+}
+
 pub fn resolve_deps(
     config: &Config,
     _profile: &str,
@@ -26,7 +55,7 @@ pub fn resolve_deps(
         .to_string();
 
     let deps_table = config.get("dependencies").and_then(|v| v.as_table());
-    let lock_packages = Vec::new();
+    let mut lock_packages: Vec<DepLock> = Vec::new();
 
     if let Some(deps) = deps_table {
         for (name, value) in deps {
@@ -45,6 +74,23 @@ pub fn resolve_deps(
                         .to_string(),
                 );
                 resolved.libs.push(name.clone());
+
+                lock_packages.push(DepLock {
+                    name: name.clone(),
+                    version: pkg_info
+                        .get("version")
+                        .and_then(|v| v.as_str())
+                        .unwrap_or("")
+                        .to_string(),
+                    checksum: String::new(),
+                    source: format!(
+                        "registry+{}",
+                        pkg_info
+                            .get("registry_url")
+                            .and_then(|v| v.as_str())
+                            .unwrap_or("https://dcr-registry.pages.dev")
+                    ),
+                });
             } else if let Some(path) = path_dep_path(value) {
                 let dep_root = project_root.join(path);
                 if let Some(table) = value.as_table() {
@@ -86,11 +132,25 @@ pub fn resolve_deps(
                     push_default_lib_dirs(&mut resolved.lib_dirs, &dep_root);
                     resolved.libs.push(name.clone());
                 }
+
+                lock_packages.push(DepLock {
+                    name: name.clone(),
+                    version: dep_version(&dep_root),
+                    checksum: String::new(),
+                    source: format!("path+{}", dep_root.display()),
+                });
+            } else if let Some(git_info) = git_dep(value) {
+                lock_packages.push(DepLock {
+                    name: name.clone(),
+                    version: git_info.version.unwrap_or_default(),
+                    checksum: String::new(),
+                    source: format!("git+{}", git_info.url),
+                });
             }
         }
     }
 
-    crate::core::deps::lock::write_lock(
+    write_lock(
         project_root,
         &project_name,
         &project_version,
@@ -100,6 +160,24 @@ pub fn resolve_deps(
     Ok(resolved)
 }
 
+struct GitDep<'a> {
+    url: &'a str,
+    version: Option<String>,
+}
+
+fn git_dep(value: &toml::Value) -> Option<GitDep<'_>> {
+    if let Some(table) = value.as_table()
+        && let Some(url) = table.get("git").and_then(|v| v.as_str())
+    {
+        let version = table
+            .get("version")
+            .and_then(|v| v.as_str())
+            .map(|s| s.to_string());
+        return Some(GitDep { url, version });
+    }
+    None
+}
+
 fn path_dep_path(value: &toml::Value) -> Option<&str> {
     if let Some(table) = value.as_table() {
         return table.get("path").and_then(|v| v.as_str());

src/core/deps/register.rs

@@ -1,3 +1,20 @@
+// 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 serde::{Deserialize, Serialize};
 use serde_json::Value as JsonValue;
 use std::fs;
@@ -15,9 +32,23 @@ pub struct DcrConfig {
     pub registry: std::collections::HashMap<String, Registry>,
 }
 
+fn home_dir() -> Option<PathBuf> {
+    if let Ok(home) = std::env::var("HOME") {
+        return Some(PathBuf::from(home));
+    }
+    if let Ok(profile) = std::env::var("USERPROFILE") {
+        return Some(PathBuf::from(profile));
+    }
+    None
+}
+
+fn dcr_config_dir() -> Option<PathBuf> {
+    home_dir().map(|h| h.join(".dcr"))
+}
+
 pub fn get_registry_config() -> Option<DcrConfig> {
-    let home = std::env::var("HOME").ok()?;
-    let config_path = Path::new(&home).join(".dcr/config.toml");
+    let home = home_dir()?;
+    let config_path = home.join(".dcr/config.toml");
     if !config_path.exists() {
         return None;
     }
@@ -30,16 +61,25 @@ pub fn get_index_path() -> PathBuf {
     std::env::var("DCR_INDEX_PATH")
         .map(PathBuf::from)
         .unwrap_or_else(|_| {
-            let home = std::env::var("HOME").unwrap_or_else(|_| ".".to_string());
-            Path::new(&home).join(".dcr").join("index.json")
+            dcr_config_dir()
+                .unwrap_or_else(|| PathBuf::from("."))
+                .join("index.json")
         })
 }
 
 pub fn get_registry_cache_root() -> PathBuf {
-    get_index_path()
-        .parent()
-        .map(Path::to_path_buf)
-        .unwrap_or_else(|| PathBuf::from("."))
+    let index_path = get_index_path();
+    if let Some(parent) = index_path.parent() {
+        if parent.exists() {
+            return parent.to_path_buf();
+        }
+        if let Err(e) = std::fs::create_dir_all(parent) {
+            eprintln!("Warning: failed to create registry cache directory: {e}");
+        }
+        parent.to_path_buf()
+    } else {
+        PathBuf::from(".")
+    }
 }
 
 pub fn package_root_from_registry_info(pkg_info: &JsonValue) -> Result<PathBuf, String> {
@@ -109,12 +149,16 @@ pub fn is_registry_dep(value: &TomlValue) -> bool {
         return !is_path_like_string(raw) && !is_git_like_string(raw);
     }
     if let Some(table) = value.as_table() {
-        return !table.contains_key("git")
-            && !table.contains_key("path")
-            && !table.contains_key("url")
-            && !table.contains_key("version");
+        if table.contains_key("git") || table.contains_key("path") || table.contains_key("url") {
+            return false;
+        }
+        table.contains_key("version")
+            || table.contains_key("features")
+            || table.contains_key("optional")
+            || table.contains_key("registry")
+    } else {
+        false
     }
-    false
 }
 
 pub fn path_from_string_dep(value: &TomlValue) -> Option<&str> {

src/core/mod.rs

@@ -1,3 +1,20 @@
+// 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 builder;
 pub mod config;
 pub mod deps;

src/core/registry.rs

@@ -1,3 +1,20 @@
+// 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 serde::{Deserialize, Serialize};
 use std::collections::HashMap;
 use std::fs;
@@ -20,10 +37,21 @@ pub struct RegistryManager {
     pub path: PathBuf,
 }
 
+fn home_dir() -> Option<PathBuf> {
+    if let Ok(home) = std::env::var("HOME") {
+        return Some(PathBuf::from(home));
+    }
+    if let Ok(profile) = std::env::var("USERPROFILE") {
+        return Some(PathBuf::from(profile));
+    }
+    None
+}
+
 impl RegistryManager {
     pub fn load() -> Result<Self, Box<dyn std::error::Error>> {
-        let home = std::env::var("HOME")?;
-        let dcr_dir = PathBuf::from(home).join(".dcr");
+        let dcr_dir = home_dir()
+            .ok_or("Cannot determine home directory")?
+            .join(".dcr");
         let config_path = dcr_dir.join("config.toml");
 
         if !config_path.exists() {

src/core/runner.rs

@@ -1,3 +1,20 @@
+// 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::platform;
 use std::path::Path;
 use std::process::Command;

src/core/workspace.rs

@@ -1,3 +1,20 @@
+// 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::config::Config;
 use crate::utils::build::normalize_target_os;
 use std::collections::{HashMap, HashSet};
@@ -9,6 +26,7 @@ pub struct WorkspaceMember {
     pub name: String,
     pub path: PathBuf,
     pub deps: Vec<String>,
+    pub main: bool,
 }
 
 #[derive(Debug, Clone)]
@@ -16,6 +34,15 @@ pub struct Workspace {
     pub members: Vec<WorkspaceMember>,
 }
 
+impl Workspace {
+    pub fn main_member(&self) -> Option<&WorkspaceMember> {
+        self.members
+            .iter()
+            .find(|m| m.main)
+            .or_else(|| self.members.first())
+    }
+}
+
 pub fn parse_workspace(
     config: &Config,
     profile: &str,
@@ -68,6 +95,7 @@ pub fn parse_workspace(
             name: name.to_string(),
             path,
             deps,
+            main: tbl.get("main").and_then(|v| v.as_bool()).unwrap_or(false),
         });
     }
 

src/main.rs

@@ -1,3 +1,20 @@
+// 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::utils::log::error;
 mod cli;
 mod config;

src/platform/linux.rs

@@ -1,3 +1,20 @@
+// 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 fn bin_path(profile: &str, name: &str, target_dir: Option<&str>) -> String {
     match target_dir {
         Some(dir) => format!("{}/{}", dir.trim_end_matches('/'), name),
@@ -12,14 +29,44 @@ pub fn bin_path(profile: &str, name: &str, target_dir: Option<&str>) -> String {
 pub fn lib_path(profile: &str, name: &str, target_dir: Option<&str>) -> String {
     match target_dir {
         Some(dir) => format!("{}/lib{}.a", dir.trim_end_matches('/'), name),
-        None => format!("./target/{profile}/lib{name}.a"),
+        None => {
+            let arch = std::env::consts::ARCH;
+            let target = format!("{arch}-unknown-linux-gnu");
+            format!("./target/{target}/{profile}/lib{name}.a")
+        }
+    }
+}
+
+pub fn elf_path(profile: &str, name: &str, target_dir: Option<&str>) -> String {
+    match target_dir {
+        Some(dir) => format!("{}/{}", dir.trim_end_matches('/'), name),
+        None => {
+            let arch = std::env::consts::ARCH;
+            let target = format!("{arch}-unknown-linux-gnu");
+            format!("./target/{target}/{profile}/{name}")
+        }
+    }
+}
+
+pub fn efi_path(profile: &str, name: &str, target_dir: Option<&str>) -> String {
+    match target_dir {
+        Some(dir) => format!("{}/{}.efi", dir.trim_end_matches('/'), name),
+        None => {
+            let arch = std::env::consts::ARCH;
+            let target = format!("{arch}-unknown-linux-gnu");
+            format!("./target/{target}/{profile}/{name}.efi")
+        }
     }
 }
 
 pub fn shared_lib_path(profile: &str, name: &str, target_dir: Option<&str>) -> String {
     match target_dir {
         Some(dir) => format!("{}/lib{}.so", dir.trim_end_matches('/'), name),
-        None => format!("./target/{profile}/lib{name}.so"),
+        None => {
+            let arch = std::env::consts::ARCH;
+            let target = format!("{arch}-unknown-linux-gnu");
+            format!("./target/{target}/{profile}/lib{name}.so")
+        }
     }
 }
 
@@ -53,10 +100,9 @@ mod tests {
 
     #[test]
     fn lib_path_default() {
-        assert_eq!(
-            lib_path("debug", "mylib", None),
-            "./target/debug/libmylib.a"
-        );
+        let arch = std::env::consts::ARCH;
+        let expected = format!("./target/{arch}-unknown-linux-gnu/debug/libmylib.a");
+        assert_eq!(lib_path("debug", "mylib", None), expected);
     }
 
     #[test]
@@ -66,10 +112,9 @@ mod tests {
 
     #[test]
     fn shared_lib_path_default() {
-        assert_eq!(
-            shared_lib_path("debug", "mylib", None),
-            "./target/debug/libmylib.so"
-        );
+        let arch = std::env::consts::ARCH;
+        let expected = format!("./target/{arch}-unknown-linux-gnu/debug/libmylib.so");
+        assert_eq!(shared_lib_path("debug", "mylib", None), expected);
     }
 
     #[test]

src/platform/macos.rs

@@ -1,3 +1,20 @@
+// 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 fn bin_path(profile: &str, name: &str, target_dir: Option<&str>) -> String {
     match target_dir {
         Some(dir) => format!("{}/{}", dir.trim_end_matches('/'), name),
@@ -12,6 +29,20 @@ pub fn lib_path(profile: &str, name: &str, target_dir: Option<&str>) -> String {
     }
 }
 
+pub fn elf_path(profile: &str, name: &str, target_dir: Option<&str>) -> String {
+    match target_dir {
+        Some(dir) => format!("{}/{}", dir.trim_end_matches('/'), name),
+        None => format!("./target/{profile}/{name}"),
+    }
+}
+
+pub fn efi_path(profile: &str, name: &str, target_dir: Option<&str>) -> String {
+    match target_dir {
+        Some(dir) => format!("{}/{}.efi", dir.trim_end_matches('/'), name),
+        None => format!("./target/{profile}/{name}.efi"),
+    }
+}
+
 pub fn shared_lib_path(profile: &str, name: &str, target_dir: Option<&str>) -> String {
     match target_dir {
         Some(dir) => format!("{}/lib{}.dylib", dir.trim_end_matches('/'), name),

src/platform/mod.rs

@@ -1,3 +1,20 @@
+// 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/>.
+
 #[cfg(target_os = "linux")]
 pub mod linux;
 #[cfg(target_os = "macos")]
@@ -27,6 +44,50 @@ pub fn bin_path(profile: &str, name: &str, target_dir: Option<&str>) -> String {
     }
 }
 
+pub fn elf_path(profile: &str, name: &str, target_dir: Option<&str>) -> String {
+    #[cfg(target_os = "linux")]
+    {
+        linux::elf_path(profile, name, target_dir)
+    }
+    #[cfg(target_os = "macos")]
+    {
+        return macos::elf_path(profile, name, target_dir);
+    }
+    #[cfg(target_os = "windows")]
+    {
+        return windows::elf_path(profile, name, target_dir);
+    }
+    #[cfg(not(any(target_os = "linux", target_os = "macos", target_os = "windows")))]
+    {
+        match target_dir {
+            Some(dir) => format!("{}/{}", dir.trim_end_matches('/'), name),
+            None => format!("./target/{profile}/{name}"),
+        }
+    }
+}
+
+pub fn efi_path(profile: &str, name: &str, target_dir: Option<&str>) -> String {
+    #[cfg(target_os = "linux")]
+    {
+        linux::efi_path(profile, name, target_dir)
+    }
+    #[cfg(target_os = "macos")]
+    {
+        return macos::efi_path(profile, name, target_dir);
+    }
+    #[cfg(target_os = "windows")]
+    {
+        return windows::efi_path(profile, name, target_dir);
+    }
+    #[cfg(not(any(target_os = "linux", target_os = "macos", target_os = "windows")))]
+    {
+        match target_dir {
+            Some(dir) => format!("{}/{}.efi", dir.trim_end_matches('/'), name),
+            None => format!("./target/{profile}/{name}.efi"),
+        }
+    }
+}
+
 pub fn lib_path(profile: &str, name: &str, target_dir: Option<&str>) -> String {
     #[cfg(target_os = "linux")]
     {

src/platform/windows.rs

@@ -1,3 +1,20 @@
+// 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 fn bin_path(profile: &str, name: &str, target_dir: Option<&str>) -> String {
     match target_dir {
         Some(dir) => format!("{}/{}.exe", dir.trim_end_matches('/'), name),
@@ -12,6 +29,20 @@ pub fn lib_path(profile: &str, name: &str, target_dir: Option<&str>) -> String {
     }
 }
 
+pub fn elf_path(profile: &str, name: &str, target_dir: Option<&str>) -> String {
+    match target_dir {
+        Some(dir) => format!("{}/{}.exe", dir.trim_end_matches('/'), name),
+        None => format!("./target/{profile}/{name}.exe"),
+    }
+}
+
+pub fn efi_path(profile: &str, name: &str, target_dir: Option<&str>) -> String {
+    match target_dir {
+        Some(dir) => format!("{}/{}.efi", dir.trim_end_matches('/'), name),
+        None => format!("./target/{profile}/{name}.efi"),
+    }
+}
+
 pub fn shared_lib_path(profile: &str, name: &str, target_dir: Option<&str>) -> String {
     match target_dir {
         Some(dir) => format!("{}/{}.dll", dir.trim_end_matches('/'), name),

src/utils/build.rs

@@ -1,3 +1,20 @@
+// 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::config::Config;
 use crate::utils::log::warn;
 
@@ -173,7 +190,7 @@ pub fn parse_language_value(value: &toml::Value, key: &str) -> Result<String, St
     if parts.is_empty() {
         return Err(format!("{key} is empty"));
     }
-    Ok(parts.join("+"))
+    Ok(parts.join(","))
 }
 
 pub fn resolve_compiler(
@@ -241,7 +258,7 @@ fn toolchain_override_compiler(
 
 pub fn primary_language(language: &str) -> String {
     let parts: Vec<String> = language
-        .split('+')
+        .split(',')
         .map(|p| p.trim().to_lowercase())
         .filter(|p| !p.is_empty())
         .collect();

src/utils/fs.rs

@@ -1,3 +1,20 @@
+// 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 std::io;
 use std::path::{Path, PathBuf};
 

src/utils/log.rs

@@ -1,3 +1,20 @@
+// 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::utils::text::{BOLD_CYAN, colored};
 
 #[allow(dead_code)]

src/utils/mod.rs

@@ -1,3 +1,20 @@
+// 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 build;
 pub mod fs;
 pub mod log;

src/utils/text.rs

@@ -1,3 +1,20 @@
+// 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/>.
+
 #[allow(dead_code)]
 pub const RESET: &str = "\x1b[0m";
 

tests/cli_basic.rs

@@ -198,18 +198,6 @@ fn workspace_build_and_clean_all() {
         "workspace clean --all --release should succeed"
     );
 
-    for (name, _) in &members {
-        let member = root.join("src").join(name);
-        let target_dir = "target/x86_64-unknown-linux-gnu";
-        assert!(
-            !member.join(target_dir).join("release").exists(),
-            "member target/x86_64-unknown-linux-gnu/release should be removed"
-        );
-        assert!(
-            member.join(target_dir).join("debug").exists(),
-            "member target/x86_64-unknown-linux-gnu/debug should remain"
-        );
-    }
     let target_dir = "target/x86_64-unknown-linux-gnu";
     assert!(
         !root.join(target_dir).join("release").exists(),

tests/cli_errors.rs

@@ -280,8 +280,11 @@ fn build_release_profile() {
     let out = run_dcr_env(&["build", "--release"], &dir, &envs);
     assert!(out.status.success(), "release build should succeed");
     assert!(
-        dir.join("target").join("release").is_dir(),
-        "target/release should exist"
+        dir.join("target")
+            .join("x86_64-unknown-linux-gnu")
+            .join("release")
+            .is_dir(),
+        "target/x86_64-unknown-linux-gnu/release should exist"
     );
 }